Index: branches/ProgrammableProblem/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 11949)
@@ -0,0 +1,179 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.BinaryVectorEncoding {
+  [Item("BinaryVectorEncoding", "Describes a binary vector encoding.")]
+  [StorableClass]
+  public sealed class BinaryVectorEncoding : Encoding<IBinaryVectorCreator> {
+    #region Encoding Parameters
+    [Storable]
+    private IFixedValueParameter<IntValue> lengthParameter;
+    public IFixedValueParameter<IntValue> LengthParameter {
+      get { return lengthParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Length parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Length parameter value must not be null.");
+        if (lengthParameter == value) return;
+
+        if (lengthParameter != null) Parameters.Remove(lengthParameter);
+        lengthParameter = value;
+        Parameters.Add(lengthParameter);
+        OnLengthParameterChanged();
+      }
+    }
+    #endregion
+
+
+    public int Length {
+      get { return LengthParameter.Value.Value; }
+      set { LengthParameter.Value.Value = value; }
+    }
+
+    [StorableConstructor]
+    private BinaryVectorEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new BinaryVectorEncoding(this, cloner); }
+    private BinaryVectorEncoding(BinaryVectorEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      lengthParameter = cloner.Clone(original.lengthParameter);
+      RegisterParameterEvents();
+    }
+
+    public BinaryVectorEncoding() : this("BinaryVector", 10) { }
+    public BinaryVectorEncoding(string name) : this(name, 10) { }
+    public BinaryVectorEncoding(int length) : this("BinaryVector", length) { }
+    public BinaryVectorEncoding(string name, int length)
+      : base(name) {
+      lengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length));
+      Parameters.Add(lengthParameter);
+
+      SolutionCreator = new RandomBinaryVectorCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private void OnLengthParameterChanged() {
+      RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void RegisterParameterEvents() {
+      RegisterLengthParameterEvents();
+    }
+    private void RegisterLengthParameterEvents() {
+      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static BinaryVectorEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+        typeof (IBinaryVectorOperator),
+        typeof (IBinaryVectorCreator),
+        typeof (IBinaryVectorCrossover),
+        typeof (IBinaryVectorManipulator),
+        typeof (IBinaryVectorMoveOperator),
+        typeof (IBinaryVectorMultiNeighborhoodShakingOperator),
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IBinaryVectorOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        encodingOperators.Add(@operator);
+    }
+    #endregion
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+      ConfigureCreators(operators.OfType<IBinaryVectorCreator>());
+      ConfigureCrossovers(operators.OfType<IBinaryVectorCrossover>());
+      ConfigureManipulators(operators.OfType<IBinaryVectorManipulator>());
+      ConfigureMoveOperators(operators.OfType<IBinaryVectorMoveOperator>());
+      ConfigureBitFlipMoveOperators(operators.OfType<IOneBitflipMoveOperator>());
+      ConfigureShakingOperators(operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>());
+    }
+
+    #region Specific Operator Wiring
+    private void ConfigureCreators(IEnumerable<IBinaryVectorCreator> creators) {
+      foreach (var creator in creators) {
+        creator.BinaryVectorParameter.ActualName = Name;
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+      }
+    }
+    private void ConfigureCrossovers(IEnumerable<IBinaryVectorCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ParentsParameter.ActualName = Name;
+        crossover.ChildParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureManipulators(IEnumerable<IBinaryVectorManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.BinaryVectorParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureMoveOperators(IEnumerable<IBinaryVectorMoveOperator> moveOperators) {
+      foreach (var moveOperator in moveOperators) {
+        moveOperator.BinaryVectorParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureBitFlipMoveOperators(IEnumerable<IOneBitflipMoveOperator> oneBitflipMoveOperators) {
+      foreach (var oneBitFlipMoveOperator in oneBitflipMoveOperators) {
+        oneBitFlipMoveOperator.OneBitflipMoveParameter.ActualName = Name + "_OneBitFlipMove";
+      }
+    }
+    private void ConfigureShakingOperators(IEnumerable<IBinaryVectorMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.BinaryVectorParameter.ActualName = Name;
+      }
+    }
+    #endregion
+  }
+
+  public static class IndividualExtensionMethods {
+    public static BinaryVector BinaryVector(this Individual individual) {
+      var encoding = individual.GetEncoding<BinaryVectorEncoding>();
+      return individual.BinaryVector(encoding.Name);
+    }
+
+    public static BinaryVector BinaryVector(this Individual individual, string name) {
+      return (BinaryVector)individual[name];
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj	(revision 11949)
@@ -155,4 +155,5 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BinaryVectorEncoding.cs" />
     <Compile Include="Creators\RandomBinaryVectorCreator.cs" />
     <Compile Include="Crossovers\MultiBinaryVectorCrossover.cs" />
Index: branches/ProgrammableProblem/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj	(revision 11949)
@@ -169,4 +169,5 @@
     </Compile>
     <Compile Include="Crossovers\RoundedUniformArithmeticCrossover.cs" />
+    <Compile Include="IntegerVectorEncoding.cs" />
     <Compile Include="IntegerVectorOperator.cs" />
     <Compile Include="Interfaces\IBoundedIntegerVectorOperator.cs" />
Index: branches/ProgrammableProblem/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEncoding.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEncoding.cs	(revision 11949)
@@ -0,0 +1,281 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("IntegerVectorEncoding", "Describes an integer vector encoding.")]
+  [StorableClass]
+  public sealed class IntegerVectorEncoding : Encoding<IIntegerVectorCreator> {
+    #region Encoding Parameters
+    [Storable]
+    private IFixedValueParameter<IntValue> lengthParameter;
+    public IFixedValueParameter<IntValue> LengthParameter {
+      get { return lengthParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Length parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Length parameter value must not be null.");
+        if (lengthParameter == value) return;
+
+        if (lengthParameter != null) Parameters.Remove(lengthParameter);
+        lengthParameter = value;
+        Parameters.Add(lengthParameter);
+        OnLengthParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IValueParameter<IntMatrix> boundsParameter;
+    public IValueParameter<IntMatrix> BoundsParameter {
+      get { return boundsParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Bounds parameter must not be null.");
+        if (boundsParameter == value) return;
+
+        if (boundsParameter != null) Parameters.Remove(boundsParameter);
+        boundsParameter = value;
+        Parameters.Add(boundsParameter);
+        OnBoundsParameterChanged();
+      }
+    }
+    #endregion
+
+    public int Length {
+      get { return LengthParameter.Value.Value; }
+      set { LengthParameter.Value.Value = value; }
+    }
+    public IntMatrix Bounds {
+      get { return BoundsParameter.Value; }
+      set { BoundsParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    private IntegerVectorEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private IntegerVectorEncoding(IntegerVectorEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      lengthParameter = cloner.Clone(original.lengthParameter);
+      boundsParameter = cloner.Clone(original.boundsParameter);
+      RegisterParameterEvents();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new IntegerVectorEncoding(this, cloner); }
+
+
+    public IntegerVectorEncoding() : this("IntegerVector", 10) { }
+    public IntegerVectorEncoding(string name) : this(name, 10) { }
+    public IntegerVectorEncoding(int length) : this("integerVector", length) { }
+    public IntegerVectorEncoding(string name, int length, int min = int.MinValue, int max = int.MaxValue, int? step = null)
+      : base(name) {
+      if (min >= max) throw new ArgumentException("min must be less than max", "min");
+      if (step.HasValue && step.Value <= 0) throw new ArgumentException("step must be greater than zero or null", "step");
+
+      var bounds = new IntMatrix(1, step.HasValue ? 3 : 2);
+      bounds[0, 0] = min;
+      bounds[0, 1] = max;
+      if (step.HasValue) bounds[0, 2] = step.Value;
+
+      lengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length));
+      boundsParameter = new ValueParameter<IntMatrix>(Name + ".Bounds", bounds);
+      Parameters.Add(lengthParameter);
+      Parameters.Add(boundsParameter);
+
+      SolutionCreator = new UniformRandomIntegerVectorCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+    public IntegerVectorEncoding(string name, int length, IList<int> min, IList<int> max, IList<int> step = null)
+      : base(name) {
+      if (min.Count == 0) throw new ArgumentException("Bounds must be given for the integer parameters.");
+      if (min.Count != max.Count) throw new ArgumentException("min must be of the same length as max", "min");
+      if (step != null && min.Count != step.Count) throw new ArgumentException("step must be of the same length as min or null", "step");
+      if (min.Zip(max, (mi, ma) => mi >= ma).Any(x => x)) throw new ArgumentException("min must be less than max in each dimension", "min");
+
+      var bounds = new IntMatrix(min.Count, step != null ? 3 : 2);
+      for (int i = 0; i < min.Count; i++) {
+        bounds[i, 0] = min[i];
+        bounds[i, 1] = max[i];
+        if (step != null) bounds[i, 2] = step[i];
+      }
+
+      LengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length));
+      BoundsParameter = new ValueParameter<IntMatrix>(Name + ".Bounds", bounds);
+
+      SolutionCreator = new UniformRandomIntegerVectorCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private void OnLengthParameterChanged() {
+      RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnBoundsParameterChanged() {
+      RegisterBoundsParameterEvents();
+      ConfigureOperators(Operators);
+    }
+
+    private void RegisterParameterEvents() {
+      RegisterLengthParameterEvents();
+      RegisterBoundsParameterEvents();
+    }
+    private void RegisterLengthParameterEvents() {
+      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+    private void RegisterBoundsParameterEvents() {
+      BoundsParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      boundsParameter.Value.ToStringChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static IntegerVectorEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+        typeof (IIntegerVectorOperator),
+        typeof (IIntegerVectorCreator),
+        typeof (IIntegerVectorCrossover),
+        typeof (IIntegerVectorManipulator),
+        typeof (IIntegerVectorStdDevStrategyParameterOperator),
+        typeof (IIntegerVectorMultiNeighborhoodShakingOperator),
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IIntegerVectorOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        encodingOperators.Add(@operator);
+    }
+    #endregion
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+      ConfigureBoundedOperators(operators.OfType<IBoundedIntegerVectorOperator>());
+      ConfigureCreators(operators.OfType<IIntegerVectorCreator>());
+      ConfigureCrossovers(operators.OfType<IIntegerVectorCrossover>());
+      ConfigureManipulators(operators.OfType<IIntegerVectorManipulator>());
+      ConfigureShakingOperators(operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>());
+      ConfigureStrategyVectorOperator(operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>());
+    }
+
+    #region Specific Operator Wiring
+    private void ConfigureBoundedOperators(IEnumerable<IBoundedIntegerVectorOperator> boundedOperators) {
+      foreach (var boundedOperator in boundedOperators) {
+        boundedOperator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+
+    private void ConfigureCreators(IEnumerable<IIntegerVectorCreator> creators) {
+      foreach (var creator in creators) {
+        creator.IntegerVectorParameter.ActualName = Name;
+        creator.BoundsParameter.ActualName = BoundsParameter.Name;
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+      }
+    }
+
+    private void ConfigureCrossovers(IEnumerable<IIntegerVectorCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+      }
+    }
+
+    private void ConfigureManipulators(IEnumerable<IIntegerVectorManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.IntegerVectorParameter.ActualName = Name;
+        manipulator.IntegerVectorParameter.Hidden = true;
+        var sm = manipulator as ISelfAdaptiveManipulator;
+        if (sm != null) {
+          var p = sm.StrategyParameterParameter as ILookupParameter;
+          if (p != null) {
+            p.ActualName = Name + "Strategy";
+          }
+        }
+      }
+    }
+
+    private void ConfigureShakingOperators(IEnumerable<IIntegerVectorMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.IntegerVectorParameter.ActualName = Name;
+      }
+    }
+
+    private void ConfigureStrategyVectorOperator(IEnumerable<IIntegerVectorStdDevStrategyParameterOperator> strategyVectorOperators) {
+      var bounds = new DoubleMatrix(Bounds.Rows, Bounds.Columns);
+      for (var i = 0; i < bounds.Rows; i++) {
+        bounds[i, 1] = (int)Math.Ceiling(0.33 * (Bounds[i, 1] - Bounds[i, 0]));
+        bounds[i, 0] = 0;
+        if (bounds.Columns > 2) bounds[i, 2] = Bounds[i, 2];
+      }
+      foreach (var s in strategyVectorOperators) {
+        var c = s as IIntegerVectorStdDevStrategyParameterCreator;
+        if (c != null) {
+          c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          c.LengthParameter.ActualName = Name;
+          c.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+        var m = s as IIntegerVectorStdDevStrategyParameterManipulator;
+        if (m != null) {
+          m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          m.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+        var mm = s as StdDevStrategyVectorManipulator;
+        if (mm != null) {
+          mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Length));
+          mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(Length)));
+        }
+        var x = s as IIntegerVectorStdDevStrategyParameterCrossover;
+        if (x != null) {
+          x.ParentsParameter.ActualName = Name + "Strategy";
+          x.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+      }
+    }
+    #endregion
+  }
+
+  public static class IndividualExtensionMethods {
+    public static IntegerVector IntegerVector(this Individual individual) {
+      var encoding = individual.GetEncoding<IntegerVectorEncoding>();
+      return individual.IntegerVector(encoding.Name);
+    }
+    public static IntegerVector IntegerVector(this Individual individual, string name) {
+      return (IntegerVector)individual[name];
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj	(revision 11949)
@@ -233,4 +233,5 @@
     <Compile Include="Moves\TwoOpt\StochasticInversionMultiMoveGenerator.cs" />
     <Compile Include="Moves\TwoOpt\StochasticInversionSingleMoveGenerator.cs" />
+    <Compile Include="PermutationEncoding.cs" />
     <Compile Include="PermutationEqualityComparer.cs" />
     <Compile Include="PermutationManipulator.cs" />
Index: branches/ProgrammableProblem/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationEncoding.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationEncoding.cs	(revision 11949)
@@ -0,0 +1,236 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.PermutationEncoding {
+  [Item("PermutationEncoding", "Describes a permutation encoding.")]
+  [StorableClass]
+  public sealed class PermutationEncoding : Encoding<IPermutationCreator> {
+    #region encoding parameters
+    [Storable]
+    private IFixedValueParameter<IntValue> lengthParameter;
+    public IFixedValueParameter<IntValue> LengthParameter {
+      get { return lengthParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Length parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Length parameter value must not be null.");
+        if (lengthParameter == value) return;
+
+        if (lengthParameter != null) Parameters.Remove(lengthParameter);
+        lengthParameter = value;
+        Parameters.Add(lengthParameter);
+        OnLengthParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IFixedValueParameter<PermutationType> permutationTypeParameter;
+    public IFixedValueParameter<PermutationType> PermutationTypeParameter {
+      get { return permutationTypeParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Permutation type parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Permutation type parameter value must not be null.");
+        if (permutationTypeParameter == value) return;
+
+        if (permutationTypeParameter != null) Parameters.Remove(permutationTypeParameter);
+        permutationTypeParameter = value;
+        Parameters.Add(permutationTypeParameter);
+        OnPermutationTypeParameterChanged();
+      }
+    }
+    #endregion
+
+    public int Length {
+      get { return LengthParameter.Value.Value; }
+      set { LengthParameter.Value.Value = value; }
+    }
+
+    public PermutationTypes Type {
+      get { return PermutationTypeParameter.Value.Value; }
+      set { PermutationTypeParameter.Value.Value = value; }
+    }
+
+    [StorableConstructor]
+    private PermutationEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new PermutationEncoding(this, cloner); }
+    private PermutationEncoding(PermutationEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      lengthParameter = cloner.Clone(original.lengthParameter);
+      permutationTypeParameter = cloner.Clone(original.permutationTypeParameter);
+      RegisterParameterEvents();
+    }
+
+
+    public PermutationEncoding() : this("Permutation", 10, PermutationTypes.Absolute) { }
+    public PermutationEncoding(string name) : this(name, 10, PermutationTypes.Absolute) { }
+    public PermutationEncoding(int length) : this("Permuration", length, PermutationTypes.Absolute) { }
+    public PermutationEncoding(string name, int length, PermutationTypes type)
+      : base(name) {
+      lengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length));
+      permutationTypeParameter = new FixedValueParameter<PermutationType>(Name + ".Type", new PermutationType(type));
+      Parameters.Add(lengthParameter);
+      Parameters.Add(permutationTypeParameter);
+
+      SolutionCreator = new RandomPermutationCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private void OnLengthParameterChanged() {
+      RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+
+    private void OnPermutationTypeParameterChanged() {
+      RegisterPermutationTypeParameterEvents();
+      ConfigureOperators(Operators);
+    }
+
+    private void RegisterParameterEvents() {
+      RegisterLengthParameterEvents();
+      RegisterPermutationTypeParameterEvents();
+    }
+    private void RegisterLengthParameterEvents() {
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+    private void RegisterPermutationTypeParameterEvents() {
+      PermutationTypeParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static PermutationEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+          typeof (IPermutationOperator),
+          typeof (IPermutationCreator),
+          typeof (IPermutationCrossover),
+          typeof (IPermutationManipulator),
+          typeof (IPermutationMultiNeighborhoodShakingOperator),
+          typeof (IPermutationMoveOperator),
+          typeof (IPermutationInversionMoveOperator),
+          typeof (IPermutationScrambleMoveOperator),
+          typeof (IPermutationSwap2MoveOperator),                    
+          typeof (IPermutationTranslocationMoveOperator)
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IPermutationOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        encodingOperators.Add(@operator);
+    }
+    #endregion
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+      ConfigureCreators(operators.OfType<IPermutationCreator>());
+      ConfigureCrossovers(operators.OfType<IPermutationCrossover>());
+      ConfigureManipulators(operators.OfType<IPermutationManipulator>());
+      ConfigureShakingOperators(operators.OfType<IPermutationMultiNeighborhoodShakingOperator>());
+      ConfigureMoveOperators(operators.OfType<IPermutationMoveOperator>());
+      ConfigureInversionMoveOperators(operators.OfType<IPermutationInversionMoveOperator>());
+      ConfigureScrambleMoveOperators(operators.OfType<IPermutationScrambleMoveOperator>());
+      ConfigureSwap2MoveOperators(operators.OfType<IPermutationSwap2MoveOperator>());
+      ConfigureTranslocationMoveOperators(operators.OfType<IPermutationTranslocationMoveOperator>());
+    }
+
+    #region specific operator wiring
+    private void ConfigureCreators(IEnumerable<IPermutationCreator> creators) {
+      foreach (var creator in creators) {
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+        creator.PermutationParameter.ActualName = Name;
+        creator.PermutationTypeParameter.Value.Value = Type;
+      }
+    }
+    private void ConfigureCrossovers(IEnumerable<IPermutationCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureManipulators(IEnumerable<IPermutationManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.PermutationParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureShakingOperators(IEnumerable<IPermutationMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.PermutationParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureMoveOperators(IEnumerable<IPermutationMoveOperator> moveOperators) {
+      foreach (var moveOperator in moveOperators) {
+        moveOperator.PermutationParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureInversionMoveOperators(IEnumerable<IPermutationInversionMoveOperator> inversionMoveOperators) {
+      foreach (var inversionMoveOperator in inversionMoveOperators) {
+        inversionMoveOperator.InversionMoveParameter.ActualName = Name + ".InversionMove";
+      }
+    }
+    private void ConfigureScrambleMoveOperators(IEnumerable<IPermutationScrambleMoveOperator> scrambleMoveOperators) {
+      foreach (var scrambleMoveOperator in scrambleMoveOperators) {
+        scrambleMoveOperator.ScrambleMoveParameter.ActualName = Name + ".ScambleMove";
+      }
+    }
+    private void ConfigureSwap2MoveOperators(IEnumerable<IPermutationSwap2MoveOperator> swap2MoveOperators) {
+      foreach (var swap2MoveOperator in swap2MoveOperators) {
+        swap2MoveOperator.Swap2MoveParameter.ActualName = Name + ".Swap2Move";
+      }
+    }
+    private void ConfigureTranslocationMoveOperators(IEnumerable<IPermutationTranslocationMoveOperator> translocationMoveOperators) {
+      foreach (var translocationMoveOperator in translocationMoveOperators) {
+        translocationMoveOperator.TranslocationMoveParameter.ActualName = Name + ".TranslocationMove";
+      }
+    }
+
+    #endregion
+  }
+
+  public static class IndividualExtensionMethods {
+    public static Permutation Permutation(this Individual individual) {
+      var encoding = individual.GetEncoding<PermutationEncoding>();
+      return individual.Permutation(encoding.Name);
+    }
+    public static Permutation Permutation(this Individual individual, string name) {
+      return (Permutation)individual[name];
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj	(revision 11949)
@@ -176,4 +176,5 @@
     <Compile Include="RealVectorCrossover.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RealVectorEncoding.cs" />
     <Compile Include="RealVectorManipulator.cs" />
   </ItemGroup>
Index: branches/ProgrammableProblem/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs	(revision 11949)
@@ -0,0 +1,328 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  [Item("RealVectorEncoding", "Describes a real vector encoding.")]
+  [StorableClass]
+  public sealed class RealVectorEncoding : Encoding<IRealVectorCreator> {
+    #region Encoding Parameters
+    [Storable]
+    private IFixedValueParameter<IntValue> lengthParameter;
+    public IFixedValueParameter<IntValue> LengthParameter {
+      get { return lengthParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Length parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Length parameter value must not be null.");
+        if (lengthParameter == value) return;
+
+        if (lengthParameter != null) Parameters.Remove(lengthParameter);
+        lengthParameter = value;
+        Parameters.Add(lengthParameter);
+        OnLengthParameterChanged();
+      }
+    }
+    [Storable]
+    private IValueParameter<DoubleMatrix> boundsParameter;
+    public IValueParameter<DoubleMatrix> BoundsParameter {
+      get { return boundsParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Bounds parameter must not be null.");
+        if (boundsParameter == value) return;
+
+        if (boundsParameter != null) Parameters.Remove(boundsParameter);
+        boundsParameter = value;
+        Parameters.Add(boundsParameter);
+        OnBoundsParameterChanged();
+      }
+    }
+    #endregion
+
+    public int Length {
+      get { return LengthParameter.Value.Value; }
+      set { LengthParameter.Value.Value = value; }
+    }
+    public DoubleMatrix Bounds {
+      get { return BoundsParameter.Value; }
+      set { BoundsParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    private RealVectorEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new RealVectorEncoding(this, cloner); }
+    private RealVectorEncoding(RealVectorEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      lengthParameter = cloner.Clone(original.lengthParameter);
+      boundsParameter = cloner.Clone(original.boundsParameter);
+      RegisterParameterEvents();
+    }
+
+    public RealVectorEncoding() : this("RealVector", 10) { }
+    public RealVectorEncoding(string name) : this(name, 10) { }
+    public RealVectorEncoding(int length) : this("RealVector", length) { }
+    public RealVectorEncoding(string name, int length, double min = double.MinValue, double max = double.MaxValue)
+      : base(name) {
+      if (min >= max) throw new ArgumentException("min must be less than max", "min");
+
+      var bounds = new DoubleMatrix(1, 2);
+      bounds[0, 0] = min;
+      bounds[0, 1] = max;
+
+      lengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length));
+      boundsParameter = new ValueParameter<DoubleMatrix>(Name + ".Bounds", bounds);
+      Parameters.Add(lengthParameter);
+      Parameters.Add(boundsParameter);
+
+      SolutionCreator = new UniformRandomRealVectorCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    public RealVectorEncoding(string name, int length, IList<double> min, IList<double> max)
+      : base(name) {
+      if (min.Count == 0) throw new ArgumentException("Bounds must be given for the real parameters.");
+      if (min.Count != max.Count) throw new ArgumentException("min must be of the same length as max", "min");
+      if (min.Zip(max, (mi, ma) => mi >= ma).Any(x => x)) throw new ArgumentException("min must be less than max in each dimension", "min");
+
+      var bounds = new DoubleMatrix(min.Count, 2);
+      for (int i = 0; i < min.Count; i++) {
+        bounds[i, 0] = min[i];
+        bounds[i, 1] = max[i];
+      }
+      LengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length));
+      BoundsParameter = new ValueParameter<DoubleMatrix>(Name + ".Bounds", bounds);
+
+      SolutionCreator = new UniformRandomRealVectorCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private void OnLengthParameterChanged() {
+      RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnBoundsParameterChanged() {
+      RegisterBoundsParameterEvents();
+      ConfigureOperators(Operators);
+    }
+
+    private void RegisterParameterEvents() {
+      RegisterLengthParameterEvents();
+      RegisterBoundsParameterEvents();
+    }
+    private void RegisterLengthParameterEvents() {
+      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+    private void RegisterBoundsParameterEvents() {
+      BoundsParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      boundsParameter.Value.ToStringChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static RealVectorEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+          typeof (IRealVectorOperator),
+          typeof (IRealVectorCreator),
+          typeof (IRealVectorCrossover),
+          typeof (IRealVectorManipulator),
+          typeof (IRealVectorStdDevStrategyParameterOperator),
+          typeof (IRealVectorSwarmUpdater),
+          typeof (IRealVectorParticleCreator),
+          typeof (IRealVectorParticleUpdater),
+          typeof (IRealVectorMultiNeighborhoodShakingOperator),
+          typeof (IRealVectorBoundsChecker),
+          typeof (IRealVectorMoveOperator),
+          typeof (IRealVectorMoveGenerator)
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IRealVectorOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        encodingOperators.Add(@operator);
+
+      foreach (var strategyVectorCreator in Operators.OfType<IRealVectorStdDevStrategyParameterCreator>())
+        strategyVectorCreator.BoundsParameter.ValueChanged += strategyVectorCreator_BoundsParameter_ValueChanged;
+    }
+    #endregion
+
+
+    private void strategyVectorCreator_BoundsParameter_ValueChanged(object sender, EventArgs e) {
+      var boundsParameter = (IValueLookupParameter<DoubleMatrix>)sender;
+      if (boundsParameter.Value == null) return;
+      foreach (var strategyVectorManipulator in Operators.OfType<IRealVectorStdDevStrategyParameterManipulator>())
+        strategyVectorManipulator.BoundsParameter.Value = (DoubleMatrix)boundsParameter.Value.Clone();
+    }
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+      ConfigureCreators(operators.OfType<IRealVectorCreator>());
+      ConfigureCrossovers(operators.OfType<IRealVectorCrossover>());
+      ConfigureManipulators(operators.OfType<IRealVectorManipulator>());
+      ConfigureStdDevStrategyParameterOperators(operators.OfType<IRealVectorStdDevStrategyParameterOperator>());
+      ConfigureSwarmUpdaters(operators.OfType<IRealVectorSwarmUpdater>());
+      ConfigureParticleCreators(operators.OfType<IRealVectorParticleCreator>());
+      ConfigureParticleUpdaters(operators.OfType<IRealVectorParticleUpdater>());
+      ConfigureShakingOperators(operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>());
+      ConfigureBoundsCheckers(operators.OfType<IRealVectorBoundsChecker>());
+      ConfigureMoveGenerators(operators.OfType<IRealVectorMoveGenerator>());
+      ConfigureMoveOperators(operators.OfType<IRealVectorMoveOperator>());
+      ConfigureAdditiveMoveOperator(operators.OfType<IAdditiveRealVectorMoveOperator>());
+    }
+
+    #region Specific Operator Wiring
+    private void ConfigureCreators(IEnumerable<IRealVectorCreator> creators) {
+      foreach (var creator in creators) {
+        creator.RealVectorParameter.ActualName = Name;
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+        creator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureCrossovers(IEnumerable<IRealVectorCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+        crossover.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureManipulators(IEnumerable<IRealVectorManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.RealVectorParameter.ActualName = Name;
+        manipulator.BoundsParameter.ActualName = BoundsParameter.Name;
+        manipulator.BoundsParameter.Hidden = true;
+        var sm = manipulator as ISelfAdaptiveManipulator;
+        if (sm != null) {
+          var p = sm.StrategyParameterParameter as ILookupParameter;
+          if (p != null) {
+            p.ActualName = Name + ".Strategy";
+          }
+        }
+      }
+    }
+    private void ConfigureStdDevStrategyParameterOperators(IEnumerable<IRealVectorStdDevStrategyParameterOperator> strategyOperators) {
+      var bounds = new DoubleMatrix(Bounds.Rows, Bounds.Columns);
+      for (var i = 0; i < Bounds.Rows; i++) {
+        bounds[i, 0] = 0;
+        bounds[i, 1] = 0.1 * (Bounds[i, 1] - Bounds[i, 0]);
+      }
+      foreach (var s in strategyOperators) {
+        var c = s as IRealVectorStdDevStrategyParameterCreator;
+        if (c != null) {
+          c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          c.LengthParameter.ActualName = LengthParameter.Name;
+          c.StrategyParameterParameter.ActualName = Name + ".Strategy";
+        }
+        var m = s as IRealVectorStdDevStrategyParameterManipulator;
+        if (m != null) {
+          m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          m.StrategyParameterParameter.ActualName = Name + ".Strategy";
+        }
+        var mm = s as StdDevStrategyVectorManipulator;
+        if (mm != null) {
+          mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Length));
+          mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(Length)));
+        }
+        var x = s as IRealVectorStdDevStrategyParameterCrossover;
+        if (x != null) {
+          x.ParentsParameter.ActualName = Name + ".Strategy";
+          x.StrategyParameterParameter.ActualName = Name + ".Strategy";
+        }
+      }
+    }
+    private void ConfigureSwarmUpdaters(IEnumerable<IRealVectorSwarmUpdater> swarmUpdaters) {
+      foreach (var su in swarmUpdaters) {
+        su.RealVectorParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureParticleCreators(IEnumerable<IRealVectorParticleCreator> particleCreators) {
+      foreach (var particleCreator in particleCreators) {
+        particleCreator.RealVectorParameter.ActualName = Name;
+        particleCreator.BoundsParameter.ActualName = BoundsParameter.Name;
+        particleCreator.ProblemSizeParameter.ActualName = LengthParameter.Name;
+      }
+    }
+    private void ConfigureParticleUpdaters(IEnumerable<IRealVectorParticleUpdater> particleUpdaters) {
+      foreach (var particleUpdater in particleUpdaters) {
+        particleUpdater.RealVectorParameter.ActualName = Name;
+        particleUpdater.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureShakingOperators(IEnumerable<IRealVectorMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.RealVectorParameter.ActualName = Name;
+        shakingOperator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureBoundsCheckers(IEnumerable<IRealVectorBoundsChecker> boundsCheckers) {
+      foreach (var boundsChecker in boundsCheckers) {
+        boundsChecker.RealVectorParameter.ActualName = Name;
+        boundsChecker.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureMoveOperators(IEnumerable<IRealVectorMoveOperator> moveOperators) {
+      foreach (var moveOperator in moveOperators)
+        moveOperator.RealVectorParameter.ActualName = Name;
+    }
+
+    private void ConfigureMoveGenerators(IEnumerable<IRealVectorMoveGenerator> moveGenerators) {
+      foreach (var moveGenerator in moveGenerators)
+        moveGenerator.BoundsParameter.ActualName = BoundsParameter.Name;
+    }
+
+    private void ConfigureAdditiveMoveOperator(IEnumerable<IAdditiveRealVectorMoveOperator> additiveMoveOperators) {
+      foreach (var additiveMoveOperator in additiveMoveOperators) {
+        additiveMoveOperator.AdditiveMoveParameter.ActualName = Name + ".AdditiveMove";
+      }
+    }
+    #endregion
+  }
+
+  public static class IndividualExtensionMethods {
+    public static RealVector RealVector(this Individual individual) {
+      var encoding = individual.GetEncoding<RealVectorEncoding>();
+      return individual.RealVector(encoding.Name);
+    }
+    public static RealVector RealVector(this Individual individual, string name) {
+      return (RealVector)individual[name];
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/BasicProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/BasicProblem.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/BasicProblem.cs	(revision 11949)
@@ -0,0 +1,144 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [StorableClass]
+  public abstract class BasicProblem<TEncoding, TEvaluator> : HeuristicOptimizationProblem<TEvaluator, ISolutionCreator>, IProblemDefinition, IStorableContent
+    where TEncoding : class, IEncoding
+    where TEvaluator : class, IEvaluator {
+
+    public string Filename { get; set; }
+
+    protected IValueParameter<TEncoding> EncodingParameter {
+      get { return (IValueParameter<TEncoding>)Parameters["Encoding"]; }
+    }
+
+    //mkommend necessary for reuse of operators if the encoding changes
+    private TEncoding oldEncoding;
+
+    IEncoding IProblemDefinition.Encoding { get { return Encoding; } }
+    public TEncoding Encoding {
+      get { return EncodingParameter.Value; }
+      protected set {
+        if (value == null) throw new ArgumentNullException("Encoding must not be null.");
+        EncodingParameter.Value = value;
+      }
+    }
+
+    protected override IEnumerable<IItem> GetOperators() {
+      if (Encoding == null) return base.GetOperators();
+      return base.GetOperators().Concat(Encoding.Operators);
+    }
+    public override IEnumerable<IParameterizedItem> ExecutionContextItems {
+      get {
+        if (Encoding == null) return base.ExecutionContextItems;
+        return base.ExecutionContextItems.Concat(new[] { Encoding });
+      }
+    }
+
+    protected BasicProblem()
+      : base() {
+      Parameters.Add(new ValueParameter<TEncoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
+      oldEncoding = Encoding;
+      RegisterEvents();
+    }
+
+    protected BasicProblem(BasicProblem<TEncoding, TEvaluator> original, Cloner cloner)
+      : base(original, cloner) {
+      oldEncoding = cloner.Clone(original.oldEncoding);
+      RegisterEvents();
+    }
+
+    [StorableConstructor]
+    protected BasicProblem(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      oldEncoding = Encoding;
+      RegisterEvents();
+    }
+
+    private void RegisterEvents() {
+      EncodingParameter.ValueChanged += (o, e) => OnEncodingChanged();
+    }
+
+    protected virtual void OnEncodingChanged() {
+      if (oldEncoding != null) AdaptEncodingOperators(oldEncoding, Encoding);
+      oldEncoding = Encoding;
+
+      foreach (var op in Operators.OfType<IEncodingOperator>())
+        op.EncodingParameter.ActualName = EncodingParameter.Name;
+
+      var solutionCreatorType = Encoding.GetType().BaseType.GetGenericArguments();
+      var paramType = typeof(ValueParameter<>).MakeGenericType(solutionCreatorType);
+      var solutionCreatorParam = (IParameter)Activator.CreateInstance(paramType, SolutionCreatorParameter.Name, SolutionCreatorParameter.Description,
+        Encoding.SolutionCreator);
+      Parameters.Remove(SolutionCreatorParameter);
+      Parameters.Add(solutionCreatorParam);
+
+      //TODO register solution creator changed event, change access modifier to private
+      //((IValueParameter)solutionCreatorParam).ValueChanged += SolutionCreatorParameter_ValueChanged;      
+
+      OnOperatorsChanged();
+      OnReset();
+    }
+
+    protected override void OnSolutionCreatorChanged() {
+      base.OnSolutionCreatorChanged();
+      Encoding.SolutionCreator = SolutionCreator;
+    }
+
+    private static void AdaptEncodingOperators(IEncoding oldEncoding, IEncoding newEncoding) {
+      if (oldEncoding.GetType() != newEncoding.GetType()) return;
+
+      if (oldEncoding.GetType() == typeof(MultiEncoding)) {
+        var oldMultiEncoding = (MultiEncoding)oldEncoding;
+        var newMultiEncoding = (MultiEncoding)newEncoding;
+        if (!oldMultiEncoding.Encodings.SequenceEqual(newMultiEncoding.Encodings, new TypeEqualityComparer<IEncoding>())) return;
+
+        var nestedEncodings = oldMultiEncoding.Encodings.Zip(newMultiEncoding.Encodings, (o, n) => new { oldEnc = o, newEnc = n });
+        foreach (var multi in nestedEncodings)
+          AdaptEncodingOperators(multi.oldEnc, multi.newEnc);
+      }
+
+      var comparer = new TypeEqualityComparer<IOperator>();
+      var cloner = new Cloner();
+      var oldOperators = oldEncoding.Operators;
+      var newOperators = newEncoding.Operators;
+
+      cloner.RegisterClonedObject(oldEncoding, newEncoding);
+      var operators = oldOperators.Intersect(newOperators, comparer)
+                                  .Select(cloner.Clone)
+                                  .Union(newOperators, comparer).ToList();
+
+      newEncoding.ConfigureOperators(operators);
+      newEncoding.Operators = operators;
+    }
+
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs	(revision 11949)
@@ -0,0 +1,113 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("Encoding", "Base class for describing different encodings.")]
+  [StorableClass]
+  public abstract class Encoding<T> : ParameterizedNamedItem, IEncoding
+    where T : class,ISolutionCreator {
+    public override sealed bool CanChangeName {
+      get { return false; }
+    }
+
+    protected HashSet<IOperator> encodingOperators = new HashSet<IOperator>(new TypeEqualityComparer<IOperator>());
+
+    [Storable(Name = "Operators")]
+    private IEnumerable<IOperator> StorableOperators {
+      get { return encodingOperators; }
+      set { encodingOperators = new HashSet<IOperator>(value, new TypeEqualityComparer<IOperator>()); ; }
+    }
+
+    public IEnumerable<IOperator> Operators {
+      get { return encodingOperators; }
+      set {
+        if (!value.OfType<T>().Any())
+          throw new ArgumentException("The provided operators contain no suitable solution creator");
+        encodingOperators = new HashSet<IOperator>(value, new TypeEqualityComparer<IOperator>());
+
+        T newSolutionCreator = (T)encodingOperators.FirstOrDefault(o => o.GetType() == solutionCreator.GetType()) ??
+                               encodingOperators.OfType<T>().First();
+        SolutionCreator = newSolutionCreator;
+        OnOperatorsChanged();
+      }
+    }
+
+    ISolutionCreator IEncoding.SolutionCreator {
+      get { return SolutionCreator; }
+      set {
+        if (!(value is T)) throw new ArgumentException(string.Format("Cannot assign the solution creator {0} to the encoding {1}.", value.GetType().GetPrettyName(), GetType().GetPrettyName()));
+        SolutionCreator = (T)value;
+      }
+    }
+    private T solutionCreator;
+    public T SolutionCreator {
+      get {
+        return solutionCreator;
+      }
+      set {
+        if (value == null) throw new ArgumentNullException("SolutionCreator must not be null.");
+        if (solutionCreator == value) return;
+        encodingOperators.Remove(solutionCreator);
+        encodingOperators.Add(value);
+        solutionCreator = value;
+        OnSolutionCreatorChanged();
+      }
+    }
+
+    [StorableConstructor]
+    protected Encoding(bool deserializing) : base(deserializing) { }
+    protected Encoding(Encoding<T> original, Cloner cloner)
+      : base(original, cloner) {
+      encodingOperators = new HashSet<IOperator>(original.Operators.Select(cloner.Clone), new TypeEqualityComparer<IOperator>());
+      solutionCreator = cloner.Clone(original.solutionCreator);
+    }
+    protected Encoding(string name) : base(name) { }
+
+    public virtual Individual GetIndividual(IScope scope) {
+      return new SingleEncodingIndividual(this, scope);
+    }
+
+    public void ConfigureOperator(IOperator @operator) { ConfigureOperators(new[] { @operator }); }
+    public abstract void ConfigureOperators(IEnumerable<IOperator> operators);
+
+    public event EventHandler SolutionCreatorChanged;
+    protected virtual void OnSolutionCreatorChanged() {
+      ConfigureOperator(SolutionCreator);
+      var handler = SolutionCreatorChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler OperatorsChanged;
+    protected virtual void OnOperatorsChanged() {
+      ConfigureOperators(Operators);
+      var handler = OperatorsChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/Individual.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/Individual.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/Individual.cs	(revision 11949)
@@ -0,0 +1,59 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Optimization {
+  public abstract class Individual {
+    protected IEncoding Encoding { get; private set; }
+    protected IScope Scope { get; private set; }
+
+    public string Name { get { return Encoding.Name; } }
+
+    protected Individual(IEncoding encoding, IScope scope) {
+      Encoding = encoding;
+      Scope = scope;
+    }
+
+    public abstract IItem this[string name] { get; set; }
+    public abstract TEncoding GetEncoding<TEncoding>() where TEncoding : class, IEncoding;
+
+    public Individual Copy() {
+      return CopyToScope(new Scope());
+    }
+
+    public abstract Individual CopyToScope(IScope scope);
+
+    protected static IItem ExtractScopeValue(string name, IScope scope) {
+      if (!scope.Variables.ContainsKey(name)) throw new ArgumentException(string.Format(" {0} cannot be found in the provided scope.", name));
+      var value = scope.Variables[name].Value;
+      if (value == null) throw new InvalidOperationException(string.Format("Value of {0} is null.", name));
+      return value;
+    }
+
+    protected static void SetScopeValue(string name, IScope scope, IItem value) {
+      if (value == null) throw new ArgumentNullException("value");
+      if (!scope.Variables.ContainsKey(name)) scope.Variables.Add(new Variable(name, value));
+      else scope.Variables[name].Value = value;
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiEncodingIndividual.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiEncodingIndividual.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiEncodingIndividual.cs	(revision 11949)
@@ -0,0 +1,76 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Optimization {
+  public sealed class MultiEncodingIndividual : Individual {
+    private new MultiEncoding Encoding {
+      get { return (MultiEncoding)base.Encoding; }
+    }
+
+    private readonly IEnumerable<Individual> individuals;
+
+    public MultiEncodingIndividual(MultiEncoding encoding, IScope scope)
+      : base(encoding, scope) {
+      individuals = encoding.Encodings.Select(e => e.GetIndividual(scope)).ToArray();
+    }
+
+    private MultiEncodingIndividual(MultiEncoding encoding, IScope scope, IEnumerable<Individual> individuals)
+      : base(encoding, scope) {
+      this.individuals = individuals;
+    }
+
+
+    public override IItem this[string name] {
+      get {
+        var individual = individuals.SingleOrDefault(i => i.Name == name);
+        if (individual == null) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
+        return individual[name];
+      }
+      set {
+        var individual = individuals.SingleOrDefault(i => i.Name == name);
+        if (individual == null) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
+        individual[name] = value;
+      }
+    }
+
+    public override TEncoding GetEncoding<TEncoding>() {
+      TEncoding encoding;
+      try {
+        encoding = (TEncoding)Encoding.Encodings.SingleOrDefault(e => e is TEncoding);
+      } catch (InvalidOperationException) {
+        throw new InvalidOperationException(string.Format("The individual uses multiple {0} .", typeof(TEncoding).GetPrettyName()));
+      }
+      if (encoding == null) throw new InvalidOperationException(string.Format("The individual does not use a {0}.", typeof(TEncoding).GetPrettyName()));
+      return encoding;
+    }
+
+    public override Individual CopyToScope(IScope scope) {
+      var copies = individuals.Select(i => i.CopyToScope(scope)).ToArray();
+      return new MultiEncodingIndividual(Encoding, scope, copies);
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/SingleEncodingIndividual.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/SingleEncodingIndividual.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/SingleEncodingIndividual.cs	(revision 11949)
@@ -0,0 +1,57 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Optimization {
+  public sealed class SingleEncodingIndividual : Individual {
+    public SingleEncodingIndividual(IEncoding encoding, IScope scope)
+      : base(encoding, scope) {
+      if (encoding is MultiEncoding) throw new ArgumentException("A MultiEncoding must not be used for the creation of a SingleEncodingIndividual");
+      if (!scope.Variables.ContainsKey(encoding.Name)) throw new ArgumentException("The provided scope does not contain an individual.");
+    }
+
+    public override IItem this[string name] {
+      get {
+        if (Name != name) throw new ArgumentException(string.Format("{0} is not part of the individual.", name));
+        return ExtractScopeValue(Name, Scope);
+      }
+      set {
+        if (Name != name) throw new ArgumentException(string.Format("{0} is not part of the individual.", name));
+        SetScopeValue(Name, Scope, value);
+      }
+    }
+
+    public override TEncoding GetEncoding<TEncoding>() {
+      TEncoding encoding = Encoding as TEncoding;
+      if (encoding == null) throw new InvalidOperationException(string.Format("The individual does not use a {0}.", typeof(TEncoding).GetPrettyName()));
+      return encoding;
+    }
+
+    public override Individual CopyToScope(IScope scope) {
+      SetScopeValue(Name, scope, (IItem)this[Name].Clone());
+      return new SingleEncodingIndividual(Encoding, scope);
+    }
+  }
+
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs	(revision 11949)
@@ -0,0 +1,39 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Optimization {
+  public interface IEncoding : IParameterizedNamedItem {
+    ISolutionCreator SolutionCreator { get; set; }
+    IEnumerable<IOperator> Operators { get; set; }
+
+    Individual GetIndividual(IScope scope);
+    void ConfigureOperator(IOperator @operator);
+    void ConfigureOperators(IEnumerable<IOperator> operators);
+
+    event EventHandler SolutionCreatorChanged;
+    event EventHandler OperatorsChanged;
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodingOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodingOperator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodingOperator.cs	(revision 11949)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Optimization {
+  public interface IEncodingOperator : IOperator {
+    ILookupParameter<IEncoding> EncodingParameter { get; }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiEncodingOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiEncodingOperator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiEncodingOperator.cs	(revision 11949)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Optimization {
+  public interface IMultiEncodingOperator : IOperator {
+    void AddEncoding(IEncoding encoding);
+    bool RemoveEncoding(IEncoding encoding);
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 11949)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Optimization {
+  public interface IMultiObjectiveProblemDefinition : IProblemDefinition {
+    bool[] Maximization { get; }
+    double[] Evaluate(Individual individual, IRandom random);
+    void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random);
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs	(revision 11949)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Optimization {
+  public interface IProblemDefinition {
+    IEncoding Encoding { get; }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveMoveOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveMoveOperator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveMoveOperator.cs	(revision 11949)
@@ -0,0 +1,26 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Optimization {
+  public interface ISingleObjectiveMoveOperator : IMoveOperator {
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 11949)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Optimization {
+  public interface ISingleObjectiveProblemDefinition : IProblemDefinition {
+    bool Maximization { get; }
+    double Evaluate(Individual individual, IRandom random);
+    void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random);
+    IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random);
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs	(revision 11949)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Optimization {
+  internal interface IMultiObjectiveAnalysisOperator : IEncodingOperator, IAnalyzer {
+    Action<Individual[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveEvaluationOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveEvaluationOperator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveEvaluationOperator.cs	(revision 11949)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Optimization {
+  internal interface IMultiObjectiveEvaluationOperator : IMultiObjectiveEvaluator, IEncodingOperator {
+    Func<Individual, IRandom, double[]> EvaluateFunc { get; set; }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/INeighborBasedOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/INeighborBasedOperator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/INeighborBasedOperator.cs	(revision 11949)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Optimization {
+  internal interface INeighborBasedOperator : IEncodingOperator {
+    Func<Individual, IRandom, IEnumerable<Individual>> GetNeighborsFunc { get; set; }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs	(revision 11949)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Optimization {
+  internal interface ISingleObjectiveAnalysisOperator : IEncodingOperator {
+    Action<Individual[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveEvaluationOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveEvaluationOperator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveEvaluationOperator.cs	(revision 11949)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Optimization {
+  internal interface ISingleObjectiveEvaluationOperator : ISingleObjectiveEvaluator, IEncodingOperator {
+    Func<Individual, IRandom, double> EvaluateFunc { get; set; }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/MultiEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/MultiEncoding.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/MultiEncoding.cs	(revision 11949)
@@ -0,0 +1,98 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Optimization {
+  [Item("MultiEncoding", "Describes a combined encoding consisting of multiple simpler encodings.")]
+  [StorableClass]
+  public sealed class MultiEncoding : Encoding<MultiEncodingCreator> {
+
+    private readonly List<IEncoding> encodings;
+    [Storable]
+    public IEnumerable<IEncoding> Encodings {
+      get { return encodings; }
+      private set { encodings.AddRange(value); }
+    }
+
+    [StorableConstructor]
+    private MultiEncoding(bool deserializing)
+      : base(deserializing) {
+      encodings = new List<IEncoding>();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MultiEncoding(this, cloner); }
+    private MultiEncoding(MultiEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      encodings = new List<IEncoding>(original.Encodings.Select(cloner.Clone));
+    }
+    public MultiEncoding()
+      : base("MultiEncoding") {
+      encodings = new List<IEncoding>();
+      SolutionCreator = new MultiEncodingCreator();
+
+      foreach (var @operator in ApplicationManager.Manager.GetInstances<IMultiEncodingOperator>())
+        encodingOperators.Add(@operator);
+    }
+
+    public override Individual GetIndividual(IScope scope) {
+      return new MultiEncodingIndividual(this, scope);
+    }
+
+    public MultiEncoding Add(IEncoding encoding) {
+      if (encoding is MultiEncoding) throw new InvalidOperationException("Nesting of MultiEncodings is not supported.");
+      if (Encodings.Any(e => e.Name == encoding.Name)) throw new ArgumentException("Encoding name must be unique", "encoding.Name");
+      encodings.Add(encoding);
+
+      Parameters.AddRange(encoding.Parameters);
+
+      foreach (var @operator in Operators.OfType<IMultiEncodingOperator>()) {
+        @operator.AddEncoding(encoding);
+      }
+      OnEncodingsChanged();
+      return this;
+    }
+
+    public bool Remove(IEncoding encoding) {
+      var success = encodings.Remove(encoding);
+      Parameters.RemoveRange(encoding.Parameters);
+      foreach (var @operator in Operators.OfType<IMultiEncodingOperator>()) {
+        @operator.RemoveEncoding(encoding);
+      }
+      OnEncodingsChanged();
+      return success;
+    }
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+    }
+
+    public event EventHandler EncodingsChanged;
+    private void OnEncodingsChanged() {
+      var handler = EncodingsChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs	(revision 11949)
@@ -0,0 +1,87 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [StorableClass]
+  public abstract class MultiObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, MultiObjectiveEvaluator>, IMultiObjectiveHeuristicOptimizationProblem, IMultiObjectiveProblemDefinition
+  where TEncoding : class, IEncoding {
+    [StorableConstructor]
+    protected MultiObjectiveBasicProblem(bool deserializing) : base(deserializing) { }
+
+    protected MultiObjectiveBasicProblem(MultiObjectiveBasicProblem<TEncoding> original, Cloner cloner)
+      : base(original, cloner) {
+      ParameterizeOperators();
+    }
+
+    protected MultiObjectiveBasicProblem()
+      : base() {
+      Parameters.Add(new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", new BoolArray()));
+
+      Operators.Add(Evaluator);
+      Operators.Add(new MultiObjectiveAnalyzer());
+
+      ParameterizeOperators();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      ParameterizeOperators();
+    }
+
+    public abstract bool[] Maximization { get; }
+    public abstract double[] Evaluate(Individual individual, IRandom random);
+    public virtual void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) { }
+
+    protected override void OnEncodingChanged() {
+      base.OnEncodingChanged();
+      Parameters["Maximization"].ActualValue = new BoolArray(Maximization);
+    }
+
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      ParameterizeOperators();
+    }
+
+    private void ParameterizeOperators() {
+      foreach (var op in Operators.OfType<IMultiObjectiveEvaluationOperator>())
+        op.EvaluateFunc = Evaluate;
+      foreach (var op in Operators.OfType<IMultiObjectiveAnalysisOperator>())
+        op.AnalyzeAction = Analyze;
+    }
+
+
+    #region IMultiObjectiveHeuristicOptimizationProblem Members
+    IParameter IMultiObjectiveHeuristicOptimizationProblem.MaximizationParameter {
+      get { return Parameters["Maximization"]; }
+    }
+    IMultiObjectiveEvaluator IMultiObjectiveHeuristicOptimizationProblem.Evaluator {
+      get { return Evaluator; }
+    }
+    #endregion
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCreator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCreator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCreator.cs	(revision 11949)
@@ -0,0 +1,65 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("MultiEncodingCreator", "Contains solution creators that together create a multi-encoding.")]
+  [StorableClass]
+  public sealed class MultiEncodingCreator : MultiEncodingOperator<ISolutionCreator>, ISolutionCreator {
+    [StorableConstructor]
+    private MultiEncodingCreator(bool deserializing) : base(deserializing) { }
+
+    private MultiEncodingCreator(MultiEncodingCreator original, Cloner cloner) : base(original, cloner) { }
+    public MultiEncodingCreator() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiEncodingCreator(this, cloner);
+    }
+
+    public override void AddEncoding(IEncoding encoding) {
+      base.AddEncoding(encoding);
+      var parameter = GetParameter(encoding);
+      parameter.Value = encoding.SolutionCreator;
+      encoding.SolutionCreatorChanged += Encoding_SolutionCreatorChanged;
+    }
+
+    public override bool RemoveEncoding(IEncoding encoding) {
+      var success = base.RemoveEncoding(encoding);
+      encoding.SolutionCreatorChanged -= Encoding_SolutionCreatorChanged;
+      return success;
+    }
+
+    private void Encoding_SolutionCreatorChanged(object sender, EventArgs e) {
+      var encoding = (IEncoding)sender;
+      var parameter = GetParameter(encoding);
+
+      var oldCreator = parameter.ValidValues.Single(creator => creator.GetType() == encoding.SolutionCreator.GetType());
+      parameter.ValidValues.Remove(oldCreator);
+      parameter.ValidValues.Add(encoding.SolutionCreator);
+      parameter.Value = encoding.SolutionCreator;
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCrossover.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCrossover.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCrossover.cs	(revision 11949)
@@ -0,0 +1,37 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("MultiEncoding Crossover", "Applies different crossovers to cross a multi-encoding.")]
+  [StorableClass]
+  public sealed class MultiEncodingCrossover : MultiEncodingOperator<ICrossover>, ICrossover {
+    [StorableConstructor]
+    private MultiEncodingCrossover(bool deserializing) : base(deserializing) { }
+    private MultiEncodingCrossover(MultiEncodingCrossover original, Cloner cloner) : base(original, cloner) { }
+    public MultiEncodingCrossover() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new MultiEncodingCrossover(this, cloner); }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingManipulator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingManipulator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingManipulator.cs	(revision 11949)
@@ -0,0 +1,40 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("MultiEncoding Manipulator", "Applies different manipulators to change a multi-encoding.")]
+  [StorableClass]
+  public sealed class MultiEncodingManipulator : MultiEncodingOperator<IManipulator>, IManipulator {
+    [StorableConstructor]
+    private MultiEncodingManipulator(bool deserializing) : base(deserializing) { }
+    private MultiEncodingManipulator(MultiEncodingManipulator original, Cloner cloner)
+      : base(original, cloner) { }
+    public MultiEncodingManipulator() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new MultiEncodingManipulator(this, cloner); }
+
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingOperator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingOperator.cs	(revision 11949)
@@ -0,0 +1,103 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [StorableClass]
+  public abstract class MultiEncodingOperator<T> : Operator, IMultiEncodingOperator where T : class,IOperator {
+    private List<IEncoding> encodings = new List<IEncoding>();
+    [Storable(Name = "Encodings")]
+    private IEnumerable<IEncoding> StorableEncodings {
+      get { return encodings; }
+      set { encodings = new List<IEncoding>(value); }
+    }
+
+    [StorableConstructor]
+    protected MultiEncodingOperator(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected MultiEncodingOperator(MultiEncodingOperator<T> original, Cloner cloner)
+      : base(original, cloner) {
+      encodings = new List<IEncoding>(original.encodings.Select(cloner.Clone));
+      foreach (var encoding in encodings)
+        encoding.OperatorsChanged += Encoding_OperatorsChanged;
+    }
+
+    protected MultiEncodingOperator() : base() { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      foreach (var encoding in encodings)
+        encoding.OperatorsChanged += Encoding_OperatorsChanged;
+    }
+
+
+    public override IOperation Apply() {
+      var operations = Parameters.Select(p => p.ActualValue).OfType<IOperator>().Select(op => ExecutionContext.CreateOperation(op));
+      return new OperationCollection(operations);
+    }
+
+    public virtual void AddEncoding(IEncoding encoding) {
+      if (Parameters.ContainsKey(encoding.Name)) throw new ArgumentException(string.Format("Encoding {0} was already added.", encoding.Name));
+
+      encodings.Add(encoding);
+      encoding.OperatorsChanged += Encoding_OperatorsChanged;
+
+      var param = new ConstrainedValueParameter<T>(encoding.Name, new ItemSet<T>(encoding.Operators.OfType<T>()));
+      param.Value = param.ValidValues.First();
+      Parameters.Add(param);
+    }
+
+    public virtual bool RemoveEncoding(IEncoding encoding) {
+      if (!encodings.Remove(encoding)) throw new ArgumentException(string.Format("Encoding {0} was not added to the MultiEncoding.", encoding.Name));
+      encoding.OperatorsChanged -= Encoding_OperatorsChanged;
+      return Parameters.Remove(encoding.Name);
+    }
+
+    protected IConstrainedValueParameter<T> GetParameter(IEncoding encoding) {
+      if (!Parameters.ContainsKey(encoding.Name)) throw new ArgumentException(string.Format("Encoding {0} was not added to the MultiEncoding.", encoding.Name));
+
+      return (IConstrainedValueParameter<T>)Parameters[encoding.Name];
+    }
+
+    private void Encoding_OperatorsChanged(object sender, EventArgs e) {
+      var encoding = (IEncoding)sender;
+      var param = GetParameter(encoding);
+
+      var oldParameterValue = param.Value;
+      param.ValidValues.Clear();
+      foreach (var op in encoding.Operators.OfType<T>())
+        param.ValidValues.Add(op);
+
+      var newValue = param.ValidValues.FirstOrDefault(op => op.GetType() == oldParameterValue.GetType());
+      if (newValue == null) newValue = param.ValidValues.First();
+      param.Value = newValue;
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveAnalyzer.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveAnalyzer.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveAnalyzer.cs	(revision 11949)
@@ -0,0 +1,64 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("Multi-objective Analyzer", "Calls the Analyze method of the problem definition.")]
+  [StorableClass]
+  public class MultiObjectiveAnalyzer : SingleSuccessorOperator, IMultiObjectiveAnalysisOperator, IStochasticOperator {
+    public bool EnabledByDefault { get { return true; } }
+
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    }
+
+    public IScopeTreeLookupParameter<DoubleArray> QualitiesParameter {
+      get { return (IScopeTreeLookupParameter<DoubleArray>)Parameters["Qualities"]; }
+    }
+
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public Action<Individual[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
+
+    [StorableConstructor]
+    protected MultiObjectiveAnalyzer(bool deserializing) : base(deserializing) { }
+    protected MultiObjectiveAnalyzer(MultiObjectiveAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public MultiObjectiveAnalyzer() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>("Qualities", "The qualities of the parameter vector."));
+      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The results collection to write to."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var encoding = EncodingParameter.ActualValue;
+      var results = ResultsParameter.ActualValue;
+      var random = RandomParameter.ActualValue;
+
+      IEnumerable<IScope> scopes = new[] { ExecutionContext.Scope };
+      for (var i = 0; i < QualitiesParameter.Depth; i++)
+        scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b));
+
+      var individuals = scopes.Select(encoding.GetIndividual).ToArray();
+      AnalyzeAction(individuals, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results, random);
+      return base.Apply();
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveEvaluator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveEvaluator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveEvaluator.cs	(revision 11949)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("Multi-objective Evaluator", "Calls the Evaluate method of the problem definition and writes the return value into the scope.")]
+  [StorableClass]
+  public class MultiObjectiveEvaluator : SingleSuccessorOperator, IMultiObjectiveEvaluationOperator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    }
+
+    public ILookupParameter<DoubleArray> QualitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Qualities"]; }
+    }
+
+    public Func<Individual, IRandom, double[]> EvaluateFunc { get; set; }
+
+    [StorableConstructor]
+    protected MultiObjectiveEvaluator(bool deserializing) : base(deserializing) { }
+    protected MultiObjectiveEvaluator(MultiObjectiveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public MultiObjectiveEvaluator() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Qualities", "The qualities of the parameter vector."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveEvaluator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var encoding = EncodingParameter.ActualValue;
+      var individual = encoding.GetIndividual(ExecutionContext.Scope);
+      QualitiesParameter.ActualValue = new DoubleArray(EvaluateFunc(individual, random));
+      return base.Apply();
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveAnalyzer.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveAnalyzer.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveAnalyzer.cs	(revision 11949)
@@ -0,0 +1,64 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("Single-objective Analyzer", "Calls the script's Analyze method to be able to write into the results collection.")]
+  [StorableClass]
+  public sealed class SingleObjectiveAnalyzer : SingleSuccessorOperator, ISingleObjectiveAnalysisOperator, IAnalyzer, IStochasticOperator {
+    public bool EnabledByDefault { get { return true; } }
+
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    }
+
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public Action<Individual[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
+
+    [StorableConstructor]
+    private SingleObjectiveAnalyzer(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveAnalyzer(SingleObjectiveAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveAnalyzer() {
+      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
+      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The results collection to write to."));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var encoding = EncodingParameter.ActualValue;
+      var results = ResultsParameter.ActualValue;
+      var random = RandomParameter.ActualValue;
+
+      IEnumerable<IScope> scopes = new[] { ExecutionContext.Scope };
+      for (var i = 0; i < QualityParameter.Depth; i++)
+        scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b));
+
+      var individuals = scopes.Select(encoding.GetIndividual).ToArray();
+      AnalyzeAction(individuals, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results, random);
+      return base.Apply();
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveEvaluator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveEvaluator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveEvaluator.cs	(revision 11949)
@@ -0,0 +1,69 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("Single-objective Evaluator", "Calls the script's Evaluate method to get the quality value of the parameter vector.")]
+  [StorableClass]
+  public sealed class SingleObjectiveEvaluator : SingleSuccessorOperator, ISingleObjectiveEvaluationOperator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public Func<Individual, IRandom, double> EvaluateFunc { get; set; }
+
+    [StorableConstructor]
+    private SingleObjectiveEvaluator(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveEvaluator(SingleObjectiveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveEvaluator() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new SingleObjectiveEvaluator(this, cloner); }
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var encoding = EncodingParameter.ActualValue;
+      var individual = encoding.GetIndividual(ExecutionContext.Scope);
+      QualityParameter.ActualValue = new DoubleValue(EvaluateFunc(individual, random));
+      return base.Apply();
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveImprover.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveImprover.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveImprover.cs	(revision 11949)
@@ -0,0 +1,116 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("Single-objective Improver", "Improves a solution by calling GetNeighbors and Evaluate of the corresponding problem definition.")]
+  [StorableClass]
+  public sealed class SingleObjectiveImprover : SingleSuccessorOperator, INeighborBasedOperator, IImprovementOperator, ISingleObjectiveEvaluationOperator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
+    public IValueLookupParameter<IntValue> ImprovementAttemptsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["ImprovementAttempts"]; }
+    }
+
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public ILookupParameter<IntValue> LocalEvaluatedSolutionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["LocalEvaluatedSolutions"]; }
+    }
+
+    public Func<Individual, IRandom, double> EvaluateFunc { get; set; }
+    public Func<Individual, IRandom, IEnumerable<Individual>> GetNeighborsFunc { get; set; }
+
+    [StorableConstructor]
+    private SingleObjectiveImprover(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveImprover(SingleObjectiveImprover original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveImprover() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "Whether the problem should be minimized or maximized."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ImprovementAttempts", "The number of improvement attempts the operator should perform.", new IntValue(100)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of samples to draw from the neighborhood function at maximum.", new IntValue(300)));
+      Parameters.Add(new LookupParameter<IntValue>("LocalEvaluatedSolutions", "The number of solution evaluations that have been performed."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveImprover(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var encoding = EncodingParameter.ActualValue;
+      var maximize = MaximizationParameter.ActualValue.Value;
+      var maxAttempts = ImprovementAttemptsParameter.ActualValue.Value;
+      var sampleSize = SampleSizeParameter.ActualValue.Value;
+      var individual = encoding.GetIndividual(ExecutionContext.Scope);
+      var quality = QualityParameter.ActualValue == null ? EvaluateFunc(individual, random) : QualityParameter.ActualValue.Value;
+
+      var count = 0;
+      for (var i = 0; i < maxAttempts; i++) {
+        Individual best = null;
+        var bestQuality = quality;
+        foreach (var neighbor in GetNeighborsFunc(individual, random).Take(sampleSize)) {
+          var q = EvaluateFunc(neighbor, random);
+          count++;
+          if (maximize && bestQuality > q || !maximize && bestQuality < q) continue;
+          best = neighbor;
+          bestQuality = q;
+        }
+        if (best == null) break;
+        individual = best;
+        quality = bestQuality;
+      }
+
+      LocalEvaluatedSolutionsParameter.ActualValue = new IntValue(count);
+      QualityParameter.ActualValue = new DoubleValue(quality);
+      individual.CopyToScope(ExecutionContext.Scope);
+      return base.Apply();
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveEvaluator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveEvaluator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveEvaluator.cs	(revision 11949)
@@ -0,0 +1,76 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("Single-objective MoveEvaluator", "Evaluates a parameter vector that results from a move.")]
+  [StorableClass]
+  public class SingleObjectiveMoveEvaluator : SingleSuccessorOperator, ISingleObjectiveEvaluationOperator, ISingleObjectiveMoveEvaluator, IStochasticOperator, ISingleObjectiveMoveOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+
+    public Func<Individual, IRandom, double> EvaluateFunc { get; set; }
+
+    [StorableConstructor]
+    protected SingleObjectiveMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveMoveEvaluator(SingleObjectiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveMoveEvaluator() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the move."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveMoveEvaluator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var encoding = EncodingParameter.ActualValue;
+      var individual = encoding.GetIndividual(ExecutionContext.Scope);
+      MoveQualityParameter.ActualValue = new DoubleValue(EvaluateFunc(individual, random));
+      return base.Apply();
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveGenerator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveGenerator.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveGenerator.cs	(revision 11949)
@@ -0,0 +1,83 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("Single-objective MoveGenerator", "Calls the GetNeighbors method of the problem definition to obtain the moves.")]
+  [StorableClass]
+  public class SingleObjectiveMoveGenerator : SingleSuccessorOperator, INeighborBasedOperator, IMultiMoveGenerator, IStochasticOperator, ISingleObjectiveMoveOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    }
+
+    public Func<Individual, IRandom, IEnumerable<Individual>> GetNeighborsFunc { get; set; }
+
+    [StorableConstructor]
+    protected SingleObjectiveMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveMoveGenerator(SingleObjectiveMoveGenerator original, Cloner cloner)
+      : base(original, cloner) { }
+    public SingleObjectiveMoveGenerator() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to sample."));
+      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveMoveGenerator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var sampleSize = SampleSizeParameter.ActualValue.Value;
+      var encoding = EncodingParameter.ActualValue;
+      var individual = encoding.GetIndividual(ExecutionContext.Scope);
+      var nbhood = GetNeighborsFunc(individual, random).Take(sampleSize).ToList();
+
+      var moveScopes = new Scope[nbhood.Count];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString(CultureInfo.InvariantCulture.NumberFormat));
+        nbhood[i].CopyToScope(moveScopes[i]);
+      }
+      ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveMaker.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveMaker.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveMaker.cs	(revision 11949)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [Item("Single-objective MoveMaker", "Applies a move.")]
+  [StorableClass]
+  public class SingleObjectiveMoveMaker : InstrumentedOperator, IMoveMaker, ISingleObjectiveMoveOperator {
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+
+    [StorableConstructor]
+    protected SingleObjectiveMoveMaker(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveMoveMaker(SingleObjectiveMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveMoveMaker() {
+      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the move."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveMoveMaker(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      if (MoveQualityParameter.ActualValue == null) throw new InvalidOperationException("Move has not been evaluated!");
+
+      var encoding = EncodingParameter.ActualValue;
+      var individual = encoding.GetIndividual(ExecutionContext.Scope);
+      individual.CopyToScope(ExecutionContext.Scope.Parent.Parent);
+
+      if (QualityParameter.ActualValue == null) QualityParameter.ActualValue = new DoubleValue(MoveQualityParameter.ActualValue.Value);
+      else QualityParameter.ActualValue.Value = MoveQualityParameter.ActualValue.Value;
+
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveBasicProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveBasicProblem.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveBasicProblem.cs	(revision 11949)
@@ -0,0 +1,103 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [StorableClass]
+  public abstract class SingleObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, SingleObjectiveEvaluator>,
+    ISingleObjectiveProblemDefinition, ISingleObjectiveHeuristicOptimizationProblem
+  where TEncoding : class, IEncoding {
+    [StorableConstructor]
+    protected SingleObjectiveBasicProblem(bool deserializing) : base(deserializing) { }
+
+    protected SingleObjectiveBasicProblem(SingleObjectiveBasicProblem<TEncoding> original, Cloner cloner)
+      : base(original, cloner) {
+      ParameterizeOperators();
+    }
+
+    protected SingleObjectiveBasicProblem()
+      : base() {
+      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", new BoolValue()));
+      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
+
+      Operators.Add(Evaluator);
+      Operators.Add(new SingleObjectiveAnalyzer());
+      Operators.Add(new SingleObjectiveImprover());
+      Operators.Add(new SingleObjectiveMoveEvaluator());
+      Operators.Add(new SingleObjectiveMoveGenerator());
+      Operators.Add(new SingleObjectiveMoveMaker());
+
+      ParameterizeOperators();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      ParameterizeOperators();
+    }
+
+    public abstract bool Maximization { get; }
+    public abstract double Evaluate(Individual individual, IRandom random);
+    public virtual void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) { }
+    public virtual IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
+      return Enumerable.Empty<Individual>();
+    }
+
+
+    protected override void OnEncodingChanged() {
+      base.OnEncodingChanged();
+      var max = (BoolValue)Parameters["Maximization"].ActualValue;
+      max.Value = Maximization;
+    }
+
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      ParameterizeOperators();
+    }
+
+    private void ParameterizeOperators() {
+      foreach (var op in Operators.OfType<ISingleObjectiveEvaluationOperator>())
+        op.EvaluateFunc = Evaluate;
+      foreach (var op in Operators.OfType<ISingleObjectiveAnalysisOperator>())
+        op.AnalyzeAction = Analyze;
+      foreach (var op in Operators.OfType<INeighborBasedOperator>())
+        op.GetNeighborsFunc = GetNeighbors;
+    }
+
+    #region ISingleObjectiveHeuristicOptimizationProblem Members
+    IParameter ISingleObjectiveHeuristicOptimizationProblem.MaximizationParameter {
+      get { return Parameters["Maximization"]; }
+    }
+    IParameter ISingleObjectiveHeuristicOptimizationProblem.BestKnownQualityParameter {
+      get { return Parameters["BestKnownQuality"]; }
+    }
+    ISingleObjectiveEvaluator ISingleObjectiveHeuristicOptimizationProblem.Evaluator {
+      get { return Evaluator; }
+    }
+    #endregion
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 11949)
@@ -125,4 +125,8 @@
       <Private>False</Private>
     </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Parameters-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
@@ -153,4 +157,36 @@
   <ItemGroup>
     <Compile Include="Algorithms\BasicAlgorithm.cs" />
+    <Compile Include="BasicProblems\BasicProblem.cs" />
+    <Compile Include="BasicProblems\Encoding.cs" />
+    <Compile Include="BasicProblems\Individuals\Individual.cs" />
+    <Compile Include="BasicProblems\Individuals\MultiEncodingIndividual.cs" />
+    <Compile Include="BasicProblems\Individuals\SingleEncodingIndividual.cs" />
+    <Compile Include="BasicProblems\Interfaces\IEncoding.cs" />
+    <Compile Include="BasicProblems\Interfaces\IEncodingOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\IMultiEncodingOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\IMultiObjectiveProblemDefinition.cs" />
+    <Compile Include="BasicProblems\Interfaces\internal\IMultiObjectiveAnalysisOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\internal\IMultiObjectiveEvaluationOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\internal\INeighborBasedOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\internal\ISingleObjectiveAnalysisOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\internal\ISingleObjectiveEvaluationOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\IProblemDefinition.cs" />
+    <Compile Include="BasicProblems\Interfaces\ISingleObjectiveMoveOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\ISingleObjectiveProblemDefinition.cs" />
+    <Compile Include="BasicProblems\MultiEncoding.cs" />
+    <Compile Include="BasicProblems\MultiObjectiveBasicProblem.cs" />
+    <Compile Include="BasicProblems\Operators\MultiEncodingCreator.cs" />
+    <Compile Include="BasicProblems\Operators\MultiEncodingCrossover.cs" />
+    <Compile Include="BasicProblems\Operators\MultiEncodingManipulator.cs" />
+    <Compile Include="BasicProblems\Operators\MultiEncodingOperator.cs" />
+    <Compile Include="BasicProblems\Operators\MultiObjectiveAnalyzer.cs" />
+    <Compile Include="BasicProblems\Operators\MultiObjectiveEvaluator.cs" />
+    <Compile Include="BasicProblems\Operators\SingleObjectiveAnalyzer.cs" />
+    <Compile Include="BasicProblems\Operators\SingleObjectiveEvaluator.cs" />
+    <Compile Include="BasicProblems\Operators\SingleObjectiveImprover.cs" />
+    <Compile Include="BasicProblems\Operators\SingleObjectiveMoveEvaluator.cs" />
+    <Compile Include="BasicProblems\Operators\SingleObjectiveMoveGenerator.cs" />
+    <Compile Include="BasicProblems\Operators\SingleObjectiveMoveMaker.cs" />
+    <Compile Include="BasicProblems\SingleObjectiveBasicProblem.cs" />
     <Compile Include="Interfaces\ILocalImprovementAlgorithmOperator.cs" />
     <Compile Include="Interfaces\ISingleObjectivePathRelinker.cs" />
Index: branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/Plugin.cs.frame
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/Plugin.cs.frame	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Optimization/3.3/Plugin.cs.frame	(revision 11949)
@@ -33,4 +33,5 @@
   [PluginDependency("HeuristicLab.Core", "3.3")]
   [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/CreateNewSingleEncodingDialog.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/CreateNewSingleEncodingDialog.cs	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/CreateNewSingleEncodingDialog.cs	(revision 11949)
@@ -23,4 +23,5 @@
 using System.Collections.Generic;
 using System.Windows.Forms;
+using HeuristicLab.Optimization;
 using HeuristicLab.PluginInfrastructure;
 
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/MultiEncodingView.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/MultiEncodingView.cs	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/MultiEncodingView.cs	(revision 11949)
@@ -28,4 +28,5 @@
 using HeuristicLab.Core.Views;
 using HeuristicLab.MainForm;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.Programmable.Views {
@@ -81,12 +82,15 @@
           try {
             encoding = (IEncoding)Activator.CreateInstance(dialog.EncodingType, dialog.EncodingName);
-          } catch (MissingMethodException mmex) {
+          }
+          catch (MissingMethodException mmex) {
             PluginInfrastructure.ErrorHandling.ShowErrorDialog(
               "The encoding must have a constructor that takes the name as a single string argument", mmex);
             return;
-          } catch (TargetInvocationException tiex) {
+          }
+          catch (TargetInvocationException tiex) {
             PluginInfrastructure.ErrorHandling.ShowErrorDialog("The encoding could not be created due to an error in the constructor.", tiex);
             return;
-          } catch (MethodAccessException maex) {
+          }
+          catch (MethodAccessException maex) {
             PluginInfrastructure.ErrorHandling.ShowErrorDialog("The encoding's string constructor is not public.", maex);
             return;
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs	(revision 11949)
@@ -0,0 +1,45 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.Programmable {
+  public abstract class CompiledProblemDefinition : IProblemDefinition {
+    private IEncoding encoding;
+    public IEncoding Encoding {
+      get { return encoding; }
+      protected set {
+        if (value == null) throw new ArgumentNullException("The encoding must not be null.");
+        encoding = value;
+      }
+    }
+
+    public dynamic vars { get; set; }
+    public abstract void Initialize();
+
+    protected CompiledProblemDefinition() { }
+    protected CompiledProblemDefinition(IEncoding encoding)
+      : base() {
+      Encoding = encoding;
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 11949)
@@ -40,9 +40,4 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="HeuristicLab.Analysis-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -55,9 +50,4 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -68,25 +58,4 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.BinaryVectorEncoding-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Encodings.PermutationEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.PermutationEncoding-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
-      <Private>False</Private>
     </Reference>
     <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
@@ -109,9 +78,4 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="HeuristicLab.Scripting-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -129,56 +93,19 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Individuals\MultiEncodingIndividual.cs" />
-    <Compile Include="Encodings\PermutationEncoding.cs" />
-    <Compile Include="Encodings\RealVectorEncoding.cs" />
-    <Compile Include="Encodings\IntegerVectorEncoding.cs" />
-    <Compile Include="Encodings\BinaryVectorEncoding.cs" />
-    <Compile Include="Encodings\MultiEncoding.cs" />
-    <Compile Include="Encodings\Encoding.cs" />
-    <Compile Include="Individuals\Individual.cs" />
-    <Compile Include="Individuals\SingleEncodingIndividual.cs" />
-    <Compile Include="Interfaces\IEncoding.cs" />
-    <Compile Include="Interfaces\IMultiEncodingOperator.cs" />
-    <Compile Include="Interfaces\internal\INeighborBasedOperator.cs" />
-    <Compile Include="Interfaces\internal\IMultiObjectiveAnalysisOperator.cs" />
-    <Compile Include="Interfaces\internal\ISingleObjectiveAnalysisOperator.cs" />
-    <Compile Include="Interfaces\internal\IMultiObjectiveEvaluationOperator.cs" />
-    <Compile Include="Interfaces\internal\ISingleObjectiveEvaluationOperator.cs" />
-    <Compile Include="Interfaces\IMultiObjectiveProblemDefinition.cs" />
-    <Compile Include="Interfaces\IEncodingOperator.cs" />
-    <Compile Include="Interfaces\ISingleObjectiveMoveOperator.cs" />
-    <Compile Include="New\BasicProblem.cs" />
-    <Compile Include="New\MultiObjectiveBasicProblem.cs" />
-    <Compile Include="New\MultiObjectiveProgrammableProblem.cs" />
-    <Compile Include="New\Scripts\ProblemDefinitionScriptException.cs" />
-    <Compile Include="New\Scripts\Templates\CompiledMultiObjectiveProblemDefinition.cs" />
-    <Compile Include="New\Scripts\Templates\CompiledSingleObjectiveProblemDefinition.cs" />
-    <Compile Include="New\Scripts\Templates\ScriptTemplates.Designer.cs">
+    <Compile Include="MultiObjectiveProgrammableProblem.cs" />
+    <Compile Include="ProblemDefinitionScriptException.cs" />
+    <Compile Include="Templates\CompiledMultiObjectiveProblemDefinition.cs" />
+    <Compile Include="Templates\CompiledSingleObjectiveProblemDefinition.cs" />
+    <Compile Include="Templates\ScriptTemplates.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
       <DependentUpon>ScriptTemplates.resx</DependentUpon>
     </Compile>
-    <Compile Include="Operators\MultiEncodingManipulator.cs" />
-    <Compile Include="Operators\MultiEncodingCrossover.cs" />
-    <Compile Include="Operators\MultiEncodingOperator.cs" />
-    <Compile Include="Operators\SingleObjectiveMoveEvaluator.cs" />
-    <Compile Include="Operators\SingleObjectiveMoveGenerator.cs" />
-    <Compile Include="Operators\SingleObjectiveMoveMaker.cs" />
-    <Compile Include="Operators\MultiObjectiveAnalyzer.cs" />
-    <Compile Include="Operators\SingleObjectiveAnalyzer.cs" />
-    <Compile Include="Operators\MultiObjectiveEvaluator.cs" />
-    <Compile Include="Operators\SingleObjectiveEvaluator.cs" />
-    <Compile Include="Operators\MultiEncodingCreator.cs" />
-    <Compile Include="Interfaces\IProblemDefinition.cs" />
-    <Compile Include="Interfaces\ISingleObjectiveProblemDefinition.cs" />
-    <Compile Include="Operators\SingleObjectiveImprover.cs" />
-    <Compile Include="New\Scripts\CompiledProblemDefinition.cs" />
-    <Compile Include="New\Scripts\ProblemDefinitionScript.cs" />
-    <Compile Include="New\OneMaxNew.cs" />
-    <Compile Include="New\SingleObjectiveBasicProblem.cs" />
-    <Compile Include="New\SingleObjectiveProgrammableProblem.cs" />
-    <Compile Include="New\Scripts\MultiObjectiveProblemDefinitionScript.cs" />
-    <Compile Include="New\Scripts\SingleObjectiveProblemDefinitionScript.cs" />
-    <EmbeddedResource Include="New\Scripts\Templates\ScriptTemplates.resx">
+    <Compile Include="CompiledProblemDefinition.cs" />
+    <Compile Include="ProblemDefinitionScript.cs" />
+    <Compile Include="SingleObjectiveProgrammableProblem.cs" />
+    <Compile Include="MultiObjectiveProblemDefinitionScript.cs" />
+    <Compile Include="SingleObjectiveProblemDefinitionScript.cs" />
+    <EmbeddedResource Include="Templates\ScriptTemplates.resx">
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>ScriptTemplates.Designer.cs</LastGenOutput>
@@ -191,4 +118,20 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.BinaryVectorEncoding\3.3\HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj">
+      <Project>{66d249c3-a01d-42a8-82a2-919bc8ec3d83}</Project>
+      <Name>HeuristicLab.Encodings.BinaryVectorEncoding-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.IntegerVectorEncoding\3.3\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj">
+      <Project>{ddfb14dd-2a85-493c-a52d-e69729bbaeb0}</Project>
+      <Name>HeuristicLab.Encodings.IntegerVectorEncoding-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.PermutationEncoding\3.3\HeuristicLab.Encodings.PermutationEncoding-3.3.csproj">
+      <Project>{dbecb8b0-b166-4133-baf1-ed67c3fd7fca}</Project>
+      <Name>HeuristicLab.Encodings.PermutationEncoding-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.RealVectorEncoding\3.3\HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj">
+      <Project>{bb6d334a-4bb6-4674-9883-31a6ebb32cab}</Project>
+      <Name>HeuristicLab.Encodings.RealVectorEncoding-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
       <Project>{14ab8d24-25bc-400c-a846-4627aa945192}</Project>
@@ -196,4 +139,5 @@
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinitionScript.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinitionScript.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinitionScript.cs	(revision 11949)
@@ -0,0 +1,66 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("Multi-objective Problem Definition Script", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
+  [StorableClass]
+  public class MultiObjectiveProblemDefinitionScript : ProblemDefinitionScript, IMultiObjectiveProblemDefinition, IStorableContent {
+    public string Filename { get; set; }
+
+    protected override string CodeTemplate {
+      get { return ScriptTemplates.CompiledMultiObjectiveProblemDefinition; }
+    }
+
+    private new IMultiObjectiveProblemDefinition CompiledProblemDefinition {
+      get { return (IMultiObjectiveProblemDefinition)base.CompiledProblemDefinition; }
+    }
+
+    [StorableConstructor]
+    protected MultiObjectiveProblemDefinitionScript(bool deserializing) : base(deserializing) { }
+    protected MultiObjectiveProblemDefinitionScript(MultiObjectiveProblemDefinitionScript original, Cloner cloner)
+      : base(original, cloner) { }
+
+    public MultiObjectiveProblemDefinitionScript() {
+      Code = CodeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveProblemDefinitionScript(this, cloner);
+    }
+
+    bool[] IMultiObjectiveProblemDefinition.Maximization {
+      get { return CompiledProblemDefinition.Maximization; }
+    }
+
+    double[] IMultiObjectiveProblemDefinition.Evaluate(Individual individual, IRandom random) {
+      return CompiledProblemDefinition.Evaluate(individual, random);
+    }
+
+    void IMultiObjectiveProblemDefinition.Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+      CompiledProblemDefinition.Analyze(individuals, qualities, results, random);
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 11949)
@@ -0,0 +1,88 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("Programmable Problem (multi-objective)", "Represents a multi-objective problem that can be programmed with a script.")]
+  [Creatable("1 Test")]
+  [StorableClass]
+  public sealed class MultiObjectiveProgrammableProblem : MultiObjectiveBasicProblem<IEncoding> {
+
+    private FixedValueParameter<MultiObjectiveProblemDefinitionScript> MultiObjectiveProblemScriptParameter {
+      get { return (FixedValueParameter<MultiObjectiveProblemDefinitionScript>)Parameters["ProblemScript"]; }
+    }
+
+    public MultiObjectiveProblemDefinitionScript ProblemScript {
+      get { return MultiObjectiveProblemScriptParameter.Value; }
+    }
+
+    public IMultiObjectiveProblemDefinition ProblemDefinition {
+      get { return MultiObjectiveProblemScriptParameter.Value; }
+    }
+
+    private MultiObjectiveProgrammableProblem(MultiObjectiveProgrammableProblem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEvents();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MultiObjectiveProgrammableProblem(this, cloner); }
+
+    [StorableConstructor]
+    private MultiObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
+    public MultiObjectiveProgrammableProblem()
+      : base() {
+      Parameters.Add(new FixedValueParameter<MultiObjectiveProblemDefinitionScript>("ProblemScript", "Defines the problem.", new MultiObjectiveProblemDefinitionScript() { Name = Name }));
+      RegisterEvents();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
+
+    private void RegisterEvents() {
+      ProblemScript.ProblemDefinitionChanged += (o, e) => OnProblemDefinitionChanged();
+    }
+
+    private void OnProblemDefinitionChanged() {
+      Encoding = ProblemDefinition.Encoding;
+      OnOperatorsChanged();
+      OnReset();
+    }
+
+    public override bool[] Maximization {
+      get { return ProblemDefinition.Maximization; }
+    }
+
+    public override double[] Evaluate(Individual individual, IRandom random) {
+      return ProblemDefinition.Evaluate(individual, random);
+    }
+
+    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+      ProblemDefinition.Analyze(individuals, qualities, results, random);
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Plugin.cs.frame
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Plugin.cs.frame	(revision 11946)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Plugin.cs.frame	(revision 11949)
@@ -25,19 +25,11 @@
   [Plugin("HeuristicLab.Problems.Programmable", "Programmable problem for defining custom representation and evaluation function.", "3.3.9.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.Programmable-3.3.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
   [PluginDependency("HeuristicLab.Core", "3.3")]
-  [PluginDependency("HeuristicLab.Data", "3.3")]
-  [PluginDependency("HeuristicLab.Encodings.BinaryVectorEncoding", "3.3")]
-  [PluginDependency("HeuristicLab.Encodings.IntegerVectorEncoding", "3.3")]
-  [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
-  [PluginDependency("HeuristicLab.Encodings.PermutationEncoding", "3.3")]
   [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
-  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
   [PluginDependency("HeuristicLab.Scripting", "3.3")]
   public class HeuristicLabProblemsProgrammablePlugin : PluginBase { }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinitionScript.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinitionScript.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinitionScript.cs	(revision 11949)
@@ -0,0 +1,131 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using System.Reflection;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Scripting;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("ProblemDefinitionScript", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
+  [StorableClass]
+  public abstract class ProblemDefinitionScript : Script, IProblemDefinition {
+    protected bool SuppressEvents { get; set; }
+
+    [Storable]
+    private VariableStore variableStore;
+    public VariableStore VariableStore {
+      get { return variableStore; }
+    }
+
+    [Storable]
+    private bool codeChanged;
+
+    [StorableConstructor]
+    protected ProblemDefinitionScript(bool deserializing) : base(deserializing) { }
+    protected ProblemDefinitionScript(ProblemDefinitionScript original, Cloner cloner)
+      : base(original, cloner) {
+      variableStore = cloner.Clone(original.variableStore);
+      codeChanged = original.codeChanged;
+    }
+    protected ProblemDefinitionScript()
+      : base() {
+      variableStore = new VariableStore();
+    }
+
+    IEncoding IProblemDefinition.Encoding {
+      get { return CompiledProblemDefinition.Encoding; }
+    }
+
+    private readonly object compileLock = new object();
+    private volatile IProblemDefinition compiledProblemDefinition;
+    protected IProblemDefinition CompiledProblemDefinition {
+      get {
+        // double checked locking pattern
+        if (compiledProblemDefinition == null) {
+          lock (compileLock) {
+            if (compiledProblemDefinition == null) {
+              if (codeChanged) throw new ProblemDefinitionScriptException("The code has been changed, but was not recompiled.");
+              Compile(false);
+            }
+          }
+        }
+        return compiledProblemDefinition;
+      }
+    }
+
+    public sealed override Assembly Compile() {
+      return Compile(true);
+    }
+
+    private Assembly Compile(bool fireChanged) {
+      var assembly = base.Compile();
+      var types = assembly.GetTypes();
+      if (!types.Any(x => typeof(CompiledProblemDefinition).IsAssignableFrom(x)))
+        throw new ProblemDefinitionScriptException("The compiled code doesn't contain a problem definition." + Environment.NewLine + "The problem definition must be a subclass of CompiledProblemDefinition.");
+      if (types.Count(x => typeof(CompiledProblemDefinition).IsAssignableFrom(x)) > 1)
+        throw new ProblemDefinitionScriptException("The compiled code contains multiple problem definitions." + Environment.NewLine + "Only one subclass of CompiledProblemDefinition is allowed.");
+
+      CompiledProblemDefinition inst;
+      try {
+        inst = (CompiledProblemDefinition)Activator.CreateInstance(types.Single(x => typeof(CompiledProblemDefinition).IsAssignableFrom(x)));
+      } catch (Exception e) {
+        compiledProblemDefinition = null;
+        throw new ProblemDefinitionScriptException("Instantiating the problem definition failed." + Environment.NewLine + "Check your default constructor.", e);
+      }
+
+      try {
+        inst.vars = new Variables(VariableStore);
+        inst.Initialize();
+      } catch (Exception e) {
+        compiledProblemDefinition = null;
+        throw new ProblemDefinitionScriptException("Initializing the problem definition failed." + Environment.NewLine + "Check your Initialize() method.", e);
+      }
+
+      try {
+        compiledProblemDefinition = inst;
+        if (fireChanged) OnProblemDefinitionChanged();
+      } catch (Exception e) {
+        compiledProblemDefinition = null;
+        throw new ProblemDefinitionScriptException("Using the problem definition in the problem failed." + Environment.NewLine + "Examine this error message carefully (often there is an issue with the defined encoding).", e);
+      }
+
+      codeChanged = false;
+      return assembly;
+    }
+
+    protected override void OnCodeChanged() {
+      base.OnCodeChanged();
+      compiledProblemDefinition = null;
+      codeChanged = true;
+    }
+
+    public event EventHandler ProblemDefinitionChanged;
+    protected virtual void OnProblemDefinitionChanged() {
+      var handler = ProblemDefinitionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinitionScriptException.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinitionScriptException.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinitionScriptException.cs	(revision 11949)
@@ -0,0 +1,35 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Runtime.Serialization;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Serializable]
+  public class ProblemDefinitionScriptException : Exception {
+    public ProblemDefinitionScriptException() { }
+    public ProblemDefinitionScriptException(string message) : base(message) { }
+    public ProblemDefinitionScriptException(string message, Exception inner) : base(message, inner) { }
+
+    protected ProblemDefinitionScriptException(SerializationInfo info, StreamingContext context)
+      : base(info, context) { }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinitionScript.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinitionScript.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinitionScript.cs	(revision 11949)
@@ -0,0 +1,69 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("Single-objective Problem Definition Script", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
+  [StorableClass]
+  public sealed class SingleObjectiveProblemDefinitionScript : ProblemDefinitionScript, ISingleObjectiveProblemDefinition, IStorableContent {
+    public string Filename { get; set; }
+
+    protected override string CodeTemplate {
+      get { return ScriptTemplates.CompiledSingleObjectiveProblemDefinition; }
+    }
+
+    private new ISingleObjectiveProblemDefinition CompiledProblemDefinition {
+      get { return (ISingleObjectiveProblemDefinition)base.CompiledProblemDefinition; }
+    }
+
+    [StorableConstructor]
+    private SingleObjectiveProblemDefinitionScript(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveProblemDefinitionScript(SingleObjectiveProblemDefinitionScript original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveProblemDefinitionScript()
+      : base() {
+      Code = CodeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveProblemDefinitionScript(this, cloner);
+    }
+
+    bool ISingleObjectiveProblemDefinition.Maximization {
+      get { return CompiledProblemDefinition.Maximization; }
+    }
+
+    double ISingleObjectiveProblemDefinition.Evaluate(Individual individual, IRandom random) {
+      return CompiledProblemDefinition.Evaluate(individual, random);
+    }
+
+    void ISingleObjectiveProblemDefinition.Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      CompiledProblemDefinition.Analyze(individuals, qualities, results, random);
+    }
+    IEnumerable<Individual> ISingleObjectiveProblemDefinition.GetNeighbors(Individual individual, IRandom random) {
+      return CompiledProblemDefinition.GetNeighbors(individual, random);
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 11949)
@@ -0,0 +1,90 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("Programmable Problem (single-objective)", "Represents a single-objective problem that can be programmed with a script.")]
+  [Creatable("1 Test")]
+  [StorableClass]
+  public sealed class SingleObjectiveProgrammableProblem : SingleObjectiveBasicProblem<IEncoding> {
+
+    private FixedValueParameter<SingleObjectiveProblemDefinitionScript> SingleObjectiveProblemScriptParameter {
+      get { return (FixedValueParameter<SingleObjectiveProblemDefinitionScript>)Parameters["ProblemScript"]; }
+    }
+
+    public SingleObjectiveProblemDefinitionScript ProblemScript {
+      get { return SingleObjectiveProblemScriptParameter.Value; }
+    }
+
+    public ISingleObjectiveProblemDefinition ProblemDefinition {
+      get { return SingleObjectiveProblemScriptParameter.Value; }
+    }
+
+    private SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEvents();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new SingleObjectiveProgrammableProblem(this, cloner); }
+
+    [StorableConstructor]
+    private SingleObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
+    public SingleObjectiveProgrammableProblem()
+      : base() {
+      Parameters.Add(new FixedValueParameter<SingleObjectiveProblemDefinitionScript>("ProblemScript", "Defines the problem.", new SingleObjectiveProblemDefinitionScript() { Name = Name }));
+      RegisterEvents();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
+
+    private void RegisterEvents() {
+      ProblemScript.ProblemDefinitionChanged += (o, e) => OnProblemDefinitionChanged();
+    }
+
+    private void OnProblemDefinitionChanged() {
+      Encoding = ProblemDefinition.Encoding;
+    }
+
+    public override bool Maximization {
+      get { return ProblemDefinition.Maximization; }
+    }
+
+    public override double Evaluate(Individual individual, IRandom random) {
+      return ProblemDefinition.Evaluate(individual, random);
+    }
+
+    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      ProblemDefinition.Analyze(individuals, qualities, results, random);
+    }
+    public override IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
+      return ProblemDefinition.GetNeighbors(individual, random);
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/CompiledMultiObjectiveProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/CompiledMultiObjectiveProblemDefinition.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/CompiledMultiObjectiveProblemDefinition.cs	(revision 11949)
@@ -0,0 +1,49 @@
+﻿using System;
+using System.Linq;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.Programmable;
+
+namespace HeuristicLab.Problems.Programmable {
+  public class CompiledMultiObjectiveProblemDefinition : CompiledProblemDefinition, IMultiObjectiveProblemDefinition {
+    public bool[] Maximization { get { return new[] { false, false }; } }
+
+    public override void Initialize() {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
+      // Define the solution encoding which can also consist of multiple vectors, examples below
+      //Encoding = new BinaryVectorEncoding("b", length: 5);
+      //Encoding = new IntegerVectorEncoding("i", length: 5, min: 2, max: 14, step: 4);
+      //Encoding = new RealVectorEncoding("r", length: 5, min: -1.0, max: 1.0);
+      //Encoding = new PermutationEncoding("p", length: 5, type: PermutationTypes.Absolute);
+      // The encoding can also be a combination
+      //Encoding = new MultiEncoding()
+      //.Add(new BinaryVectorEncoding("b", length: 5))
+      //.Add(new IntegerVectorEncoding("i", length: 5, min: 2, max: 14, step: 4))
+      //.Add(new RealVectorEncoding("r", length: 5, min: -1.0, max: 1.0))
+      //.Add(new PermutationEncoding("p", length: 5, type: PermutationTypes.Absolute))
+      ;
+      // Add additional initialization code e.g. private variables that you need for evaluating
+    }
+
+    public double[] Evaluate(Individual individual, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
+      var qualities = new[] { 0.0, 0.0 };
+      //qualities = new [] { individual.RealVector("r").Sum(x => x * x), individual.RealVector("r").Sum(x => x * x * x) };
+      return qualities;
+    }
+
+    public void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
+      // Write or update results given the range of vectors and resulting qualities
+    }
+    // Implement further classes and methods
+  }
+}
+
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/CompiledSingleObjectiveProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/CompiledSingleObjectiveProblemDefinition.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/CompiledSingleObjectiveProblemDefinition.cs	(revision 11949)
@@ -0,0 +1,70 @@
+﻿using System;
+using System.Linq;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.Programmable;
+
+namespace HeuristicLab.Problems.Programmable {
+  public class CompiledSingleObjectiveProblemDefinition : CompiledProblemDefinition, ISingleObjectiveProblemDefinition {
+    public bool Maximization { get { return false; } }
+
+    public override void Initialize() {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
+      // Define the solution encoding which can also consist of multiple vectors, examples below
+      //Encoding = new BinaryVectorEncoding("b", length: 5);
+      //Encoding = new IntegerVectorEncoding("i", length: 5, min: 2, max: 14, step: 2);
+      //Encoding = new RealVectorEncoding("r", length: 5, min: -1.0, max: 1.0);
+      //Encoding = new PermutationEncoding("p", length: 5, type: PermutationTypes.Absolute);
+      // The encoding can also be a combination
+      //Encoding = new MultiEncoding()
+      //.Add(new BinaryVectorEncoding("b", length: 5))
+      //.Add(new IntegerVectorEncoding("i", length: 5, min: 2, max: 14, step: 4))
+      //.Add(new RealVectorEncoding("r", length: 5, min: -1.0, max: 1.0))
+      //.Add(new PermutationEncoding("p", length: 5, type: PermutationTypes.Absolute))
+      ;
+      // Add additional initialization code e.g. private variables that you need for evaluating
+    }
+
+    public double Evaluate(Individual individual, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
+      var quality = 0.0;
+      //quality = individual.RealVector("r").Sum(x => x * x);
+      return quality;
+    }
+
+    public void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
+      // Write or update results given the range of vectors and resulting qualities
+      // Uncomment the following lines if you want to retrieve the best individual
+      //var bestIndex = Maximization ?
+      //         qualities.Select((v, i) => Tuple.Create(i, v)).OrderByDescending(x => x.Item2).First().Item1
+      //       : qualities.Select((v, i) => Tuple.Create(i, v)).OrderBy(x => x.Item2).First().Item1;
+      //var best = individuals[bestIndex];
+    }
+
+    public IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
+      // Create new vectors, based on the given one that represent small changes
+      // This method is only called from move-based algorithms (Local Search, Simulated Annealing, etc.)
+      while (true) {
+        // Algorithm will draw only a finite amount of samples
+        // Change to a for-loop to return a concrete amount of neighbors
+        var neighbor = individual.Copy();
+        // For instance, perform a single bit-flip in a binary parameter
+        //var bIndex = random.Next(neighbor.BinaryVector("b").Length);
+        //neighbor.BinaryVector("b")[bIndex] = !neighbor.BinaryVector("b")[bIndex];
+        yield return neighbor;
+      }
+    }
+
+    // Implement further classes and methods
+  }
+}
+
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/ScriptTemplates.Designer.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/ScriptTemplates.Designer.cs	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/ScriptTemplates.Designer.cs	(revision 11949)
@@ -0,0 +1,107 @@
+﻿//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.18444
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace HeuristicLab.Problems.Programmable {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class ScriptTemplates {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal ScriptTemplates() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("HeuristicLab.Problems.Programmable.Templates.ScriptTemplates", typeof(ScriptTemplates).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to using System;
+        ///using System.Linq;
+        ///using System.Collections.Generic;
+        ///using HeuristicLab.Common;
+        ///using HeuristicLab.Core;
+        ///using HeuristicLab.Data;
+        ///using HeuristicLab.Encodings.PermutationEncoding;
+        ///using HeuristicLab.Optimization;
+        ///using HeuristicLab.Problems.Programmable;
+        ///
+        ///namespace HeuristicLab.Problems.Programmable {
+        ///  public class CompiledMultiObjectiveProblemDefinition : CompiledProblemDefinition, IMultiObjectiveProblemDefinition {
+        ///    public bool[] Maximization { get { return new[] { false, fal [rest of string was truncated]&quot;;.
+        /// </summary>
+        internal static string CompiledMultiObjectiveProblemDefinition {
+            get {
+                return ResourceManager.GetString("CompiledMultiObjectiveProblemDefinition", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to using System;
+        ///using System.Linq;
+        ///using System.Collections.Generic;
+        ///using HeuristicLab.Common;
+        ///using HeuristicLab.Core;
+        ///using HeuristicLab.Data;
+        ///using HeuristicLab.Encodings.PermutationEncoding;
+        ///using HeuristicLab.Optimization;
+        ///using HeuristicLab.Problems.Programmable;
+        ///
+        ///namespace HeuristicLab.Problems.Programmable {
+        ///  public class CompiledSingleObjectiveProblemDefinition : CompiledProblemDefinition, ISingleObjectiveProblemDefinition {
+        ///    public bool Maximization { get { return false; } }
+        ///
+        ///     [rest of string was truncated]&quot;;.
+        /// </summary>
+        internal static string CompiledSingleObjectiveProblemDefinition {
+            get {
+                return ResourceManager.GetString("CompiledSingleObjectiveProblemDefinition", resourceCulture);
+            }
+        }
+    }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/ScriptTemplates.resx
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/ScriptTemplates.resx	(revision 11949)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Templates/ScriptTemplates.resx	(revision 11949)
@@ -0,0 +1,127 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="CompiledMultiObjectiveProblemDefinition" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>CompiledMultiObjectiveProblemDefinition.cs;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
+  </data>
+  <data name="CompiledSingleObjectiveProblemDefinition" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>CompiledSingleObjectiveProblemDefinition.cs;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
+  </data>
+</root>
Index: branches/ProgrammableProblem/ProgrammableProblem.sln
===================================================================
--- branches/ProgrammableProblem/ProgrammableProblem.sln	(revision 11946)
+++ branches/ProgrammableProblem/ProgrammableProblem.sln	(revision 11949)
@@ -7,6 +7,4 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Programmable.Views-3.3", "HeuristicLab.Problems.Programmable.Views\3.3\HeuristicLab.Problems.Programmable.Views-3.3.csproj", "{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.TestFunctions-3.4", "HeuristicLab.Problems.TestFunctions\3.4\HeuristicLab.Problems.TestFunctions-3.4.csproj", "{88B9B0E3-344E-4196-82A3-0F9732506FE8}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Optimization-3.3", "HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj", "{14AB8D24-25BC-400C-A846-4627AA945192}"
@@ -52,16 +50,4 @@
 		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Release|x64.ActiveCfg = Release|Any CPU
 		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Release|x86.ActiveCfg = Release|Any CPU
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Debug|x64.ActiveCfg = Debug|x64
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Debug|x64.Build.0 = Debug|x64
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Debug|x86.ActiveCfg = Debug|x86
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Debug|x86.Build.0 = Debug|x86
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Release|Any CPU.Build.0 = Release|Any CPU
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Release|x64.ActiveCfg = Release|x64
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Release|x64.Build.0 = Release|x64
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Release|x86.ActiveCfg = Release|x86
-		{88B9B0E3-344E-4196-82A3-0F9732506FE8}.Release|x86.Build.0 = Release|x86
 		{14AB8D24-25BC-400C-A846-4627AA945192}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{14AB8D24-25BC-400C-A846-4627AA945192}.Debug|Any CPU.Build.0 = Debug|Any CPU
