Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab 3.3.sln
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab 3.3.sln	(revision 11571)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab 3.3.sln	(revision 11572)
@@ -2,5 +2,5 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 2013
-VisualStudioVersion = 12.0.30723.0
+VisualStudioVersion = 12.0.31101.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{96396439-A764-4022-A8D2-BE021449B8D1}"
@@ -401,4 +401,8 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.DataPreprocessing.Views-3.4", "HeuristicLab.DataPreprocessing.Views\3.4\HeuristicLab.DataPreprocessing.Views-3.4.csproj", "{3FC7515E-D8A0-41FE-8CFA-50E3ADA61A1E}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Programmable-3.3", "HeuristicLab.Problems.Programmable\3.3\HeuristicLab.Problems.Programmable-3.3.csproj", "{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}"
+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
 Global
@@ -1944,4 +1948,20 @@
 		{3FC7515E-D8A0-41FE-8CFA-50E3ADA61A1E}.Release|x64.ActiveCfg = Release|Any CPU
 		{3FC7515E-D8A0-41FE-8CFA-50E3ADA61A1E}.Release|x86.ActiveCfg = Release|Any CPU
+		{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}.Release|x64.ActiveCfg = Release|Any CPU
+		{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}.Release|x86.ActiveCfg = Release|Any CPU
+		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Release|x64.ActiveCfg = Release|Any CPU
+		{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/HeuristicLab.Problems.Programmable.Views-3.3.csproj
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/HeuristicLab.Problems.Programmable.Views-3.3.csproj	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/HeuristicLab.Problems.Programmable.Views-3.3.csproj	(revision 11572)
@@ -0,0 +1,165 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{6F023B90-2091-40A9-8AC0-B0338DFF8E5F}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.Programmable.Views</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.Programmable.Views-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Plugin.cs" />
+    <Compile Include="ProblemDefinitionScriptView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="ProblemDefinitionScriptView.Designer.cs">
+      <DependentUpon>ProblemDefinitionScriptView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="MultiObjectiveProgrammableProblemView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="MultiObjectiveProgrammableProblemView.Designer.cs">
+      <DependentUpon>MultiObjectiveProgrammableProblemView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="SingleObjectiveProgrammableProblemView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="SingleObjectiveProgrammableProblemView.Designer.cs">
+      <DependentUpon>SingleObjectiveProgrammableProblemView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.CodeEditor\3.3\HeuristicLab.CodeEditor-3.3.csproj">
+      <Project>{489cfe09-fdf7-4c89-bab5-bd09cadd61ad}</Project>
+      <Name>HeuristicLab.CodeEditor-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958b43bc-cc5c-4fa2-8628-2b3b01d890b6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
+      <Project>{0e27a536-1c4a-4624-a65e-dc4f4f23e3e1}</Project>
+      <Name>HeuristicLab.Common.Resources-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{a9ad58b9-3ef9-4cc1-97e5-8d909039ff5c}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core.Views\3.3\HeuristicLab.Core.Views-3.3.csproj">
+      <Project>{e226881d-315f-423d-b419-a766fe0d8685}</Project>
+      <Name>HeuristicLab.Core.Views-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{c36bd924-a541-4a00-afa8-41701378ddc5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data.Views\3.3\HeuristicLab.Data.Views-3.3.csproj">
+      <Project>{72104a0b-90e7-42f3-9abe-9bbbadd4b943}</Project>
+      <Name>HeuristicLab.Data.Views-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.MainForm.WindowsForms\3.3\HeuristicLab.MainForm.WindowsForms-3.3.csproj">
+      <Project>{ab687bbe-1bfe-476b-906d-44237135431d}</Project>
+      <Name>HeuristicLab.MainForm.WindowsForms-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.MainForm\3.3\HeuristicLab.MainForm-3.3.csproj">
+      <Project>{3bd61258-31da-4b09-89c0-4f71fef5f05a}</Project>
+      <Name>HeuristicLab.MainForm-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14ab8d24-25bc-400c-a846-4627aa945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186a6a-5176-4402-ae83-886557b53cca}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.Programmable\3.3\HeuristicLab.Problems.Programmable-3.3.csproj">
+      <Project>{ee07bff8-b23d-41f5-8ad7-ac9598d7a2c9}</Project>
+      <Name>HeuristicLab.Problems.Programmable-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Scripting.Views\3.3\HeuristicLab.Scripting.Views-3.3.csproj">
+      <Project>{0c2917c8-7aa8-4e18-800a-c4d064f992ed}</Project>
+      <Name>HeuristicLab.Scripting.Views-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Scripting\3.3\HeuristicLab.Scripting-3.3.csproj">
+      <Project>{21977cc3-1757-4b3b-87bd-ff817aaa900f}</Project>
+      <Name>HeuristicLab.Scripting-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/MultiObjectiveProgrammableProblemView.Designer.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/MultiObjectiveProgrammableProblemView.Designer.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/MultiObjectiveProgrammableProblemView.Designer.cs	(revision 11572)
@@ -0,0 +1,62 @@
+﻿#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
+
+namespace HeuristicLab.Problems.Programmable.Views {
+  partial class MultiObjectiveProgrammableProblemView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.SuspendLayout();
+      // 
+      // ProgrammableProblemView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Name = "ProgrammableProblemView";
+      this.Size = new System.Drawing.Size(626, 413);
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/MultiObjectiveProgrammableProblemView.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/MultiObjectiveProgrammableProblemView.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/MultiObjectiveProgrammableProblemView.cs	(revision 11572)
@@ -0,0 +1,75 @@
+﻿#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.Windows.Forms;
+using HeuristicLab.Core.Views;
+using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
+
+namespace HeuristicLab.Problems.Programmable.Views {
+  [View("Multi-Objective Programmable Problem View")]
+  [Content(typeof(MultiObjectiveProgrammableProblem), true)]
+  public partial class MultiObjectiveProgrammableProblemView : ItemView {
+    protected ViewHost DefinitionView;
+
+    public new MultiObjectiveProgrammableProblem Content {
+      get { return (MultiObjectiveProgrammableProblem)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public MultiObjectiveProgrammableProblemView() {
+      InitializeComponent();
+      DefinitionView = new ViewHost() { ViewsLabelVisible = false, Dock = DockStyle.Fill };
+      Controls.Add(DefinitionView);
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+        DefinitionView.Content = null;
+      } else {
+        DefinitionView.Content = Content.ProblemDefinitionParameter.Value;
+        Caption = Content.Name;
+      }
+    }
+
+    protected override void RegisterContentEvents() {
+      Content.ProblemDefinitionParameter.ValueChanged += ProblemDefinitionParameterOnValueChanged;
+      Content.NameChanged += ContentOnNameChanged;
+      base.RegisterContentEvents();
+    }
+
+    protected override void DeregisterContentEvents() {
+      base.DeregisterContentEvents();
+      Content.ProblemDefinitionParameter.ValueChanged -= ProblemDefinitionParameterOnValueChanged;
+      Content.NameChanged -= ContentOnNameChanged;
+    }
+
+    private void ProblemDefinitionParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      DefinitionView.Content = Content.ProblemDefinitionParameter.Value;
+    }
+
+    private void ContentOnNameChanged(object sender, EventArgs eventArgs) {
+      Caption = Content.Name;
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/Plugin.cs.frame	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/Plugin.cs.frame	(revision 11572)
@@ -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 HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.Programmable.Views {
+  [Plugin("HeuristicLab.Problems.Programmable.Views", "Views for programmable problem for defining custom representation and evaluation function.", "3.3.9.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.Programmable.Views-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Core.Views", "3.3")]
+  [PluginDependency("HeuristicLab.Data.Views", "3.3")]
+  [PluginDependency("HeuristicLab.MainForm", "3.3")]
+  [PluginDependency("HeuristicLab.MainForm.WindowsForms", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.Programmable", "3.3")]
+  [PluginDependency("HeuristicLab.Scripting", "3.3")]
+  [PluginDependency("HeuristicLab.Scripting.Views", "3.3")]
+  public class HeuristicLabProblemsProgrammableViewsPlugin : PluginBase { }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.Designer.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.Designer.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.Designer.cs	(revision 11572)
@@ -0,0 +1,173 @@
+﻿#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
+
+
+namespace HeuristicLab.Problems.Programmable.Views {
+  partial class ProblemDefinitionScriptView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ProblemDefinitionScriptView));
+      this.splitContainer2 = new System.Windows.Forms.SplitContainer();
+      this.variableStoreView = new HeuristicLab.Scripting.Views.VariableStoreView();
+      this.infoTabControl.SuspendLayout();
+      this.outputTabPage.SuspendLayout();
+      this.errorListTabPage.SuspendLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
+      this.splitContainer1.Panel1.SuspendLayout();
+      this.splitContainer1.Panel2.SuspendLayout();
+      this.splitContainer1.SuspendLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      ((System.ComponentModel.ISupportInitialize)(this.splitContainer2)).BeginInit();
+      this.splitContainer2.Panel1.SuspendLayout();
+      this.splitContainer2.Panel2.SuspendLayout();
+      this.splitContainer2.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // compileButton
+      // 
+      this.toolTip.SetToolTip(this.compileButton, "Compile (F6)");
+      // 
+      // infoTabControl
+      // 
+      this.infoTabControl.Size = new System.Drawing.Size(593, 113);
+      // 
+      // outputTabPage
+      // 
+      this.outputTabPage.Size = new System.Drawing.Size(585, 87);
+      // 
+      // outputTextBox
+      // 
+      this.outputTextBox.Size = new System.Drawing.Size(579, 81);
+      // 
+      // errorListTabPage
+      // 
+      this.errorListTabPage.Size = new System.Drawing.Size(621, 86);
+      // 
+      // errorListView
+      // 
+      this.errorListView.Size = new System.Drawing.Size(615, 80);
+      // 
+      // codeEditor
+      // 
+      this.codeEditor.Size = new System.Drawing.Size(593, 429);
+      // 
+      // splitContainer1
+      // 
+      this.splitContainer1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)));
+      this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.splitContainer1.FixedPanel = System.Windows.Forms.FixedPanel.Panel2;
+      this.splitContainer1.Location = new System.Drawing.Point(0, 0);
+      this.splitContainer1.Size = new System.Drawing.Size(593, 546);
+      this.splitContainer1.SplitterDistance = 429;
+      // 
+      // nameTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
+      // 
+      // splitContainer2
+      // 
+      this.splitContainer2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+            | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.splitContainer2.FixedPanel = System.Windows.Forms.FixedPanel.Panel2;
+      this.splitContainer2.Location = new System.Drawing.Point(6, 56);
+      this.splitContainer2.Name = "splitContainer2";
+      // 
+      // splitContainer2.Panel1
+      // 
+      this.splitContainer2.Panel1.Controls.Add(this.splitContainer1);
+      // 
+      // splitContainer2.Panel2
+      // 
+      this.splitContainer2.Panel2.Controls.Add(this.variableStoreView);
+      this.splitContainer2.Size = new System.Drawing.Size(826, 546);
+      this.splitContainer2.SplitterDistance = 593;
+      this.splitContainer2.TabIndex = 10;
+      // 
+      // variableStoreView
+      // 
+      this.variableStoreView.Caption = "ItemCollection View";
+      this.variableStoreView.Content = null;
+      this.variableStoreView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.variableStoreView.Location = new System.Drawing.Point(0, 0);
+      this.variableStoreView.Name = "variableStoreView";
+      this.variableStoreView.ReadOnly = false;
+      this.variableStoreView.Size = new System.Drawing.Size(229, 546);
+      this.variableStoreView.TabIndex = 10;
+      // 
+      // ProblemDefinitionScriptView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.splitContainer2);
+      this.Name = "ProblemDefinitionScriptView";
+      this.Controls.SetChildIndex(this.compilationLabel, 0);
+      this.Controls.SetChildIndex(this.compileButton, 0);
+      this.Controls.SetChildIndex(this.splitContainer2, 0);
+      this.Controls.SetChildIndex(this.nameLabel, 0);
+      this.Controls.SetChildIndex(this.nameTextBox, 0);
+      this.Controls.SetChildIndex(this.infoLabel, 0);
+      this.infoTabControl.ResumeLayout(false);
+      this.outputTabPage.ResumeLayout(false);
+      this.outputTabPage.PerformLayout();
+      this.errorListTabPage.ResumeLayout(false);
+      this.splitContainer1.Panel1.ResumeLayout(false);
+      this.splitContainer1.Panel2.ResumeLayout(false);
+      ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
+      this.splitContainer1.ResumeLayout(false);
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.splitContainer2.Panel1.ResumeLayout(false);
+      this.splitContainer2.Panel2.ResumeLayout(false);
+      ((System.ComponentModel.ISupportInitialize)(this.splitContainer2)).EndInit();
+      this.splitContainer2.ResumeLayout(false);
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.SplitContainer splitContainer2;
+    private Scripting.Views.VariableStoreView variableStoreView;
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.cs	(revision 11572)
@@ -0,0 +1,49 @@
+﻿#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.MainForm;
+using HeuristicLab.Scripting.Views;
+
+namespace HeuristicLab.Problems.Programmable.Views {
+  [View("ProblemDefinitionScriptView")]
+  [Content(typeof(ProblemScript), IsDefaultView = true)]
+  public partial class ProblemDefinitionScriptView : ScriptView {
+
+    public new ProblemScript Content {
+      get { return (ProblemScript)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public ProblemDefinitionScriptView() {
+      InitializeComponent();
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      variableStoreView.Content = Content == null ? null : Content.VariableStore;
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      variableStoreView.Enabled = Content != null && !Locked && !ReadOnly;
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/Properties/AssemblyInfo.cs.frame	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/Properties/AssemblyInfo.cs.frame	(revision 11572)
@@ -0,0 +1,56 @@
+﻿#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.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Problems.Programmable.Views")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002 - 2014 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("04b67c2a-b8ad-461f-ad4f-4587f96fda45")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.9.$WCREV$")]
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/SingleObjectiveProgrammableProblemView.Designer.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/SingleObjectiveProgrammableProblemView.Designer.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/SingleObjectiveProgrammableProblemView.Designer.cs	(revision 11572)
@@ -0,0 +1,62 @@
+﻿#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
+
+namespace HeuristicLab.Problems.Programmable.Views {
+  partial class SingleObjectiveProgrammableProblemView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.SuspendLayout();
+      // 
+      // ProgrammableProblemView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Name = "ProgrammableProblemView";
+      this.Size = new System.Drawing.Size(626, 413);
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/SingleObjectiveProgrammableProblemView.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/SingleObjectiveProgrammableProblemView.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable.Views/3.3/SingleObjectiveProgrammableProblemView.cs	(revision 11572)
@@ -0,0 +1,75 @@
+﻿#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.Windows.Forms;
+using HeuristicLab.Core.Views;
+using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
+
+namespace HeuristicLab.Problems.Programmable.Views {
+  [View("Single-Objective Programmable Problem View")]
+  [Content(typeof(SingleObjectiveProgrammableProblem), true)]
+  public partial class SingleObjectiveProgrammableProblemView : ItemView {
+    protected ViewHost DefinitionView;
+
+    public new SingleObjectiveProgrammableProblem Content {
+      get { return (SingleObjectiveProgrammableProblem)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public SingleObjectiveProgrammableProblemView() {
+      InitializeComponent();
+      DefinitionView = new ViewHost() { ViewsLabelVisible = false, Dock = DockStyle.Fill };
+      Controls.Add(DefinitionView);
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+        DefinitionView.Content = null;
+      } else {
+        DefinitionView.Content = Content.ProblemDefinitionParameter.Value;
+        Caption = Content.Name;
+      }
+    }
+
+    protected override void RegisterContentEvents() {
+      Content.ProblemDefinitionParameter.ValueChanged += ProblemDefinitionParameterOnValueChanged;
+      Content.NameChanged += ContentOnNameChanged;
+      base.RegisterContentEvents();
+    }
+
+    protected override void DeregisterContentEvents() {
+      base.DeregisterContentEvents();
+      Content.ProblemDefinitionParameter.ValueChanged -= ProblemDefinitionParameterOnValueChanged;
+      Content.NameChanged -= ContentOnNameChanged;
+    }
+
+    private void ProblemDefinitionParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      DefinitionView.Content = Content.ProblemDefinitionParameter.Value;
+    }
+
+    private void ContentOnNameChanged(object sender, EventArgs eventArgs) {
+      Caption = Content.Name;
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/BinaryEncoding.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/BinaryEncoding.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/BinaryEncoding.cs	(revision 11572)
@@ -0,0 +1,58 @@
+﻿#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.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("BinaryEncoding", "Describes a binary vector encoding.")]
+  [StorableClass]
+  public class BinaryEncoding : Encoding {
+    [Storable]
+    private IntValue length;
+    public IntValue Length {
+      get { return length; }
+      set {
+        if (length == value) return;
+        length = value;
+        OnParameterConfigurationChanged();
+      }
+    }
+
+    [StorableConstructor]
+    protected BinaryEncoding(bool deserializing) : base(deserializing) { }
+    protected BinaryEncoding(BinaryEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      length = cloner.Clone(original.length);
+    }
+    public BinaryEncoding(string name, int length)
+      : base(name) {
+      this.length = new IntValue(length);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BinaryEncoding(this, cloner);
+    }
+
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs	(revision 11572)
@@ -0,0 +1,48 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("Encoding", "Base class for describing different encodings.")]
+  [StorableClass]
+  public abstract class Encoding : NamedItem {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    [StorableConstructor]
+    protected Encoding(bool deserializing) : base(deserializing) { }
+    protected Encoding(Encoding original, Cloner cloner)
+      : base(original, cloner) { }
+    protected Encoding(string name) : base(name) { }
+
+
+    public event EventHandler ParameterConfigurationChanged;
+    protected virtual void OnParameterConfigurationChanged() {
+      var handler = ParameterConfigurationChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/Individual.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/Individual.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/Individual.cs	(revision 11572)
@@ -0,0 +1,123 @@
+﻿#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.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.RealVectorEncoding;
+
+namespace HeuristicLab.Problems.Programmable {
+  public sealed class Individual : IDeepCloneable {
+    private readonly Dictionary<string, BinaryVector> binaryVectors;
+    private readonly Dictionary<string, IntegerVector> integerVectors;
+    private readonly Dictionary<string, RealVector> realVectors;
+    private readonly Dictionary<string, Permutation> permutationVectors;
+
+    public Individual(IEnumerable<KeyValuePair<string, BinaryVector>> binaryVectors = null,
+      IEnumerable<KeyValuePair<string, IntegerVector>> integerVectors = null,
+      IEnumerable<KeyValuePair<string, RealVector>> realVectors = null,
+      IEnumerable<KeyValuePair<string, Permutation>> permutations = null) {
+      // prevent unnecessary allocation of dictionaries for unused vectors
+      if (binaryVectors != null) this.binaryVectors = binaryVectors.ToDictionary(x => x.Key, x => x.Value);
+      if (integerVectors != null) this.integerVectors = integerVectors.ToDictionary(x => x.Key, x => x.Value);
+      if (realVectors != null) this.realVectors = realVectors.ToDictionary(x => x.Key, x => x.Value);
+      if (permutations != null) this.permutationVectors = permutations.ToDictionary(x => x.Key, x => x.Value);
+    }
+    private Individual(Individual original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      if (original.binaryVectors != null) {
+        binaryVectors = new Dictionary<string, BinaryVector>(original.binaryVectors.Comparer);
+        foreach (var param in original.binaryVectors)
+          binaryVectors[param.Key] = cloner.Clone(param.Value);
+      }
+      if (original.integerVectors != null) {
+        integerVectors = new Dictionary<string, IntegerVector>(original.integerVectors.Comparer);
+        foreach (var param in original.integerVectors)
+          integerVectors[param.Key] = cloner.Clone(param.Value);
+      }
+      if (original.realVectors != null) {
+        realVectors = new Dictionary<string, RealVector>(original.realVectors.Comparer);
+        foreach (var param in original.realVectors)
+          realVectors[param.Key] = cloner.Clone(param.Value);
+      }
+      if (original.permutationVectors != null) {
+        permutationVectors = new Dictionary<string, Permutation>(original.permutationVectors.Comparer);
+        foreach (var param in original.permutationVectors)
+          permutationVectors[param.Key] = cloner.Clone(param.Value);
+      }
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new Individual(this, cloner);
+    }
+
+    public BinaryVector BinaryVector(string name) {
+      return binaryVectors[name];
+    }
+
+    public bool BinaryValue(string name, int index) {
+      return binaryVectors[name][index];
+    }
+
+    public IEnumerable<string> BinaryNames {
+      get { return binaryVectors != null ? binaryVectors.Keys : Enumerable.Empty<string>(); }
+    }
+
+    public IntegerVector IntegerVector(string name) {
+      return integerVectors[name];
+    }
+
+    public int IntegerValue(string name, int index) {
+      return integerVectors[name][index];
+    }
+
+    public IEnumerable<string> IntegerNames {
+      get { return integerVectors != null ? integerVectors.Keys : Enumerable.Empty<string>(); }
+    }
+
+    public RealVector RealVector(string name) {
+      return realVectors[name];
+    }
+
+    public double RealValue(string name, int index) {
+      return realVectors[name][index];
+    }
+
+    public IEnumerable<string> RealNames {
+      get { return realVectors != null ? realVectors.Keys : Enumerable.Empty<string>(); }
+    }
+
+    public Permutation Permutation(string name) {
+      return permutationVectors[name];
+    }
+
+    public IEnumerable<string> PermutationNames {
+      get { return permutationVectors != null ? permutationVectors.Keys : Enumerable.Empty<string>(); }
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/IntegerEncoding.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/IntegerEncoding.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/IntegerEncoding.cs	(revision 11572)
@@ -0,0 +1,93 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("IntegerEncoding", "Describes an integer vector encoding.")]
+  [StorableClass]
+  public class IntegerEncoding : Encoding {
+    [Storable]
+    private IntValue length;
+    public IntValue Length {
+      get { return length; }
+      set {
+        if (length == value) return;
+        length = value;
+        OnParameterConfigurationChanged();
+      }
+    }
+
+    [Storable]
+    private IntMatrix bounds;
+    public IntMatrix Bounds {
+      get { return bounds; }
+      set {
+        if (bounds == value) return;
+        bounds = value;
+        OnParameterConfigurationChanged();
+      }
+    }
+
+    [StorableConstructor]
+    protected IntegerEncoding(bool deserializing) : base(deserializing) { }
+    protected IntegerEncoding(IntegerEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      length = cloner.Clone(original.length);
+      bounds = cloner.Clone(original.bounds);
+    }
+    public IntegerEncoding(string name, int length, int min, int max, 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");
+      this.length = new IntValue(length);
+      bounds = new IntMatrix(1, step.HasValue ? 3 : 2);
+      bounds[0, 0] = min;
+      bounds[0, 1] = max;
+      if (step.HasValue) bounds[0, 2] = step.Value;
+    }
+    public IntegerEncoding(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");
+      this.length = new IntValue(length);
+      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];
+      }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntegerEncoding(this, cloner);
+    }
+
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncoding.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncoding.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncoding.cs	(revision 11572)
@@ -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;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("MultiEncoding", "Describes a combined encoding consisting of multiple simpler encodings.")]
+  [StorableClass]
+  public class MultiEncoding : Encoding {
+    [Storable]
+    public KeyedItemCollection<string, Encoding> Encodings { get; protected set; }
+
+    [StorableConstructor]
+    protected MultiEncoding(bool deserializing) : base(deserializing) { }
+    protected MultiEncoding(MultiEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      Encodings = cloner.Clone(original.Encodings);
+    }
+    public MultiEncoding()
+      : base("MultiEncoding") {
+      Encodings = new NamedItemCollection<Encoding>();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiEncoding(this, cloner);
+    }
+
+    public MultiEncoding AddBinaryVector(string variableName, int length) {
+      if (Encodings.ContainsKey(variableName)) throw new ArgumentException("variableName must be unique", "variableName");
+      Encodings.Add(new BinaryEncoding(variableName, length));
+      return this;
+    }
+
+    public MultiEncoding AddIntegerVector(string variableName, int length, int min, int max, int? step = null) {
+      if (Encodings.ContainsKey(variableName)) throw new ArgumentException("variableName must be unique", "variableName");
+      Encodings.Add(new IntegerEncoding(variableName, length, min, max, step));
+      return this;
+    }
+
+    public MultiEncoding AddIntegerVector(string variableName, int length, IList<int> min, IList<int> max, IList<int> step = null) {
+      if (Encodings.ContainsKey(variableName)) throw new ArgumentException("variableName must be unique", "variableName");
+      Encodings.Add(new IntegerEncoding(variableName, length, min, max, step));
+      return this;
+    }
+
+    public MultiEncoding AddRealVector(string variableName, int length, double min, double max) {
+      if (Encodings.ContainsKey(variableName)) throw new ArgumentException("variableName must be unique", "variableName");
+      Encodings.Add(new RealEncoding(variableName, length, min, max));
+      return this;
+    }
+
+    public MultiEncoding AddRealVector(string variableName, int length, IList<double> min, IList<double> max) {
+      if (Encodings.ContainsKey(variableName)) throw new ArgumentException("variableName must be unique", "variableName");
+      Encodings.Add(new RealEncoding(variableName, length, min, max));
+      return this;
+    }
+
+    public MultiEncoding AddPermutation(string variableName, int length, PermutationTypes type) {
+      if (Encodings.ContainsKey(variableName)) throw new ArgumentException("variableName must be unique", "variableName");
+      Encodings.Add(new PermutationEncoding(variableName, length, type));
+      return this;
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.cs	(revision 11572)
@@ -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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("PermutationEncoding", "Describes a permutation encoding.")]
+  [StorableClass]
+  public class PermutationEncoding : Encoding {
+    [Storable]
+    private IntValue length;
+    public IntValue Length {
+      get { return length; }
+      set {
+        if (length == value) return;
+        length = value;
+        OnParameterConfigurationChanged();
+      }
+    }
+
+    [Storable]
+    private PermutationType type;
+    public PermutationType Type {
+      get { return type; }
+      set {
+        if (type == value) return;
+        type = value;
+        OnParameterConfigurationChanged();
+      }
+    }
+
+    [StorableConstructor]
+    protected PermutationEncoding(bool deserializing) : base(deserializing) { }
+    protected PermutationEncoding(PermutationEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      length = cloner.Clone(original.length);
+      type = cloner.Clone(original.type);
+    }
+    public PermutationEncoding(string name, int length, PermutationTypes type)
+      : base(name) {
+      this.length = new IntValue(length);
+      this.type = new PermutationType(type);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PermutationEncoding(this, cloner);
+    }
+
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs	(revision 11572)
@@ -0,0 +1,89 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("RealEncoding", "Describes a real vector encoding.")]
+  [StorableClass]
+  public class RealEncoding : Encoding {
+    [Storable]
+    private IntValue length;
+    public IntValue Length {
+      get { return length; }
+      set {
+        if (length == value) return;
+        length = value;
+        OnParameterConfigurationChanged();
+      }
+    }
+
+    [Storable]
+    private DoubleMatrix bounds;
+    public DoubleMatrix Bounds {
+      get { return bounds; }
+      set {
+        if (bounds == value) return;
+        bounds = value;
+        OnParameterConfigurationChanged();
+      }
+    }
+
+    [StorableConstructor]
+    protected RealEncoding(bool deserializing) : base(deserializing) { }
+    protected RealEncoding(RealEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      length = cloner.Clone(original.length);
+      bounds = cloner.Clone(original.bounds);
+    }
+    public RealEncoding(string name, int length, double min, double max)
+      : base(name) {
+      if (min >= max) throw new ArgumentException("min must be less than max", "min");
+      this.length = new IntValue(length);
+      bounds = new DoubleMatrix(1, 2);
+      bounds[0, 0] = min;
+      bounds[0, 1] = max;
+    }
+    public RealEncoding(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");
+      this.length = new IntValue(length);
+      bounds = new DoubleMatrix(min.Count, 2);
+      for (int i = 0; i < min.Count; i++) {
+        bounds[i, 0] = min[i];
+        bounds[i, 1] = max[i];
+      }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RealEncoding(this, cloner);
+    }
+
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Helper.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Helper.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Helper.cs	(revision 11572)
@@ -0,0 +1,115 @@
+﻿#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.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.RealVectorEncoding;
+
+namespace HeuristicLab.Problems.Programmable {
+  internal static class Helper {
+    internal static Individual Extract(IScope scope, Encoding encoding) {
+      Dictionary<string, BinaryVector> binDict = null;
+      Dictionary<string, IntegerVector> intDict = null;
+      Dictionary<string, RealVector> realDict = null;
+      Dictionary<string, Permutation> permDict = null;
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        foreach (var enc in multiEncoding.Encodings) {
+          var binConfig = enc as BinaryEncoding;
+          if (binConfig != null) {
+            if (binDict == null) binDict = new Dictionary<string, BinaryVector>();
+            binDict.Add(enc.Name, (BinaryVector)scope.Variables[enc.Name].Value);
+            continue;
+          }
+          var intConfig = enc as IntegerEncoding;
+          if (intConfig != null) {
+            if (intDict == null) intDict = new Dictionary<string, IntegerVector>();
+            intDict.Add(enc.Name, (IntegerVector)scope.Variables[enc.Name].Value);
+            continue;
+          }
+          var realConfig = enc as RealEncoding;
+          if (realConfig != null) {
+            if (realDict == null) realDict = new Dictionary<string, RealVector>();
+            realDict.Add(enc.Name, (RealVector)scope.Variables[enc.Name].Value);
+            continue;
+          }
+          var permConfig = enc as PermutationEncoding;
+          if (permConfig != null) {
+            if (permDict == null) permDict = new Dictionary<string, Permutation>();
+            permDict.Add(enc.Name, (Permutation)scope.Variables[enc.Name].Value);
+            continue;
+          }
+          throw new InvalidOperationException("Encoding for variable " + enc.Name + " not recognized.");
+        }
+      } else {
+        var binaryEncoding = encoding as BinaryEncoding;
+        var handled = binaryEncoding != null;
+        if (binaryEncoding != null) binDict = new Dictionary<string, BinaryVector>(capacity: 1) {
+            {binaryEncoding.Name, (BinaryVector)scope.Variables[binaryEncoding.Name].Value}
+          };
+        var integerEncoding = encoding as IntegerEncoding;
+        handled = handled || integerEncoding != null;
+        if (integerEncoding != null) intDict = new Dictionary<string, IntegerVector>(capacity: 1) {
+            {integerEncoding.Name, (IntegerVector)scope.Variables[integerEncoding.Name].Value}
+          };
+        var realEncoding = encoding as RealEncoding;
+        handled = handled || realEncoding != null;
+        if (realEncoding != null) realDict = new Dictionary<string, RealVector>(capacity: 1) {
+            {realEncoding.Name, (RealVector)scope.Variables[realEncoding.Name].Value}
+          };
+        var permEncoding = encoding as PermutationEncoding;
+        handled = handled || permEncoding != null;
+        if (permEncoding != null) permDict = new Dictionary<string, Permutation>(capacity: 1) {
+            {permEncoding.ItemName, (Permutation)scope.Variables[permEncoding.ItemName].Value}
+          };
+        if (!handled) throw new InvalidOperationException("Encoding for variable " + encoding.Name + " not recognized.");
+      }
+      return new Individual(binDict, intDict, realDict, permDict);
+    }
+
+    internal static void Write(IScope scope, Individual vector) {
+      foreach (var param in vector.BinaryNames) {
+        if (scope.Variables.ContainsKey(param))
+          scope.Variables[param].Value = vector.BinaryVector(param);
+        else scope.Variables.Add(new Variable(param, vector.BinaryVector(param)));
+      }
+      foreach (var param in vector.IntegerNames) {
+        if (scope.Variables.ContainsKey(param))
+          scope.Variables[param].Value = vector.IntegerVector(param);
+        else scope.Variables.Add(new Variable(param, vector.IntegerVector(param)));
+      }
+      foreach (var param in vector.RealNames) {
+        if (scope.Variables.ContainsKey(param))
+          scope.Variables[param].Value = vector.RealVector(param);
+        else scope.Variables.Add(new Variable(param, vector.RealVector(param)));
+      }
+      foreach (var param in vector.PermutationNames) {
+        if (scope.Variables.ContainsKey(param))
+          scope.Variables[param].Value = vector.Permutation(param);
+        else scope.Variables.Add(new Variable(param, vector.Permutation(param)));
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 11572)
@@ -0,0 +1,178 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.Programmable</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.Programmable-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Encodings\PermutationEncoding.cs" />
+    <Compile Include="Encodings\RealEncoding.cs" />
+    <Compile Include="Encodings\IntegerEncoding.cs" />
+    <Compile Include="Encodings\BinaryEncoding.cs" />
+    <Compile Include="Encodings\MultiEncoding.cs" />
+    <Compile Include="Encodings\Encoding.cs" />
+    <Compile Include="Encodings\Individual.cs" />
+    <Compile Include="Helper.cs" />
+    <Compile Include="Interfaces\ISingleObjectiveMoveOperator.cs" />
+    <Compile Include="Interfaces\IMultiObjectiveProblemDefinition.cs" />
+    <Compile Include="Interfaces\IMultiObjectiveProgrammableProblemAnalyzer.cs" />
+    <Compile Include="Interfaces\ISingleObjectiveProgrammableProblemAnalyzer.cs" />
+    <Compile Include="Interfaces\IMultiObjectiveProgrammableProblemEvaluator.cs" />
+    <Compile Include="Interfaces\ISingleObjectiveProgrammableProblemEvaluator.cs" />
+    <Compile Include="Operators\MultiEncodingManipulator.cs" />
+    <Compile Include="Operators\MultiEncodingCrossover.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="ProblemDefinition.cs" />
+    <Compile Include="ProblemScriptBase.cs" />
+    <Compile Include="ProblemScript.cs" />
+    <Compile Include="MultiObjectiveProblemDefinition.cs" />
+    <Compile Include="SingleObjectiveProblemDefinition.cs" />
+    <Compile Include="MultiObjectiveProblemScript.cs" />
+    <Compile Include="SingleObjectiveProblemScript.cs" />
+    <Compile Include="MultiObjectiveProgrammableProblem.cs" />
+    <Compile Include="SingleObjectiveProgrammableProblem.cs" />
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="Plugin.cs" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">
+      <Project>{887425b4-4348-49ed-a457-b7d2c26ddbf9}</Project>
+      <Name>HeuristicLab.Analysis-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958b43bc-cc5c-4fa2-8628-2b3b01d890b6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
+      <Project>{0e27a536-1c4a-4624-a65e-dc4f4f23e3e1}</Project>
+      <Name>HeuristicLab.Common.Resources-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{a9ad58b9-3ef9-4cc1-97e5-8d909039ff5c}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{c36bd924-a541-4a00-afa8-41701378ddc5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{bbab9df5-5ef3-4ba8-ade9-b36e82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+    </ProjectReference>
+    <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.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
+      <Project>{23da7ff4-d5b8-41b6-aa96-f0561d24f3ee}</Project>
+      <Name>HeuristicLab.Operators-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14ab8d24-25bc-400c-a846-4627aa945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56f9106a-079f-4c61-92f6-86a84c2d84b7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102bc7d3-0ef9-439c-8f6d-96ff0fdb8e1b}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186a6a-5176-4402-ae83-886557b53cca}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.Instances\3.3\HeuristicLab.Problems.Instances-3.3.csproj">
+      <Project>{3540e29e-4793-49e7-8ee2-fea7f61c3994}</Project>
+      <Name>HeuristicLab.Problems.Instances-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Scripting\3.3\HeuristicLab.Scripting-3.3.csproj">
+      <Project>{21977cc3-1757-4b3b-87bd-ff817aaa900f}</Project>
+      <Name>HeuristicLab.Scripting-3.3</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProblemDefinition.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 11572)
@@ -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.Problems.Programmable {
+  public interface IMultiObjectiveProblemDefinition : IProblemDefinition {
+    bool[] Maximization { get; }
+    double[] Evaluate(IRandom random, Individual individual);
+    void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results);
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemAnalyzer.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemAnalyzer.cs	(revision 11572)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.Programmable {
+  public interface IMultiObjectiveProgrammableProblemAnalyzer : IAnalyzer {
+    ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
+    ILookupParameter<Encoding> EncodingParameter { get; }
+    IScopeTreeLookupParameter<DoubleArray> QualitiesParameter { get; }
+    ILookupParameter<ResultCollection> ResultsParameter { get; }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemEvaluator.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemEvaluator.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemEvaluator.cs	(revision 11572)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.Programmable {
+  public interface IMultiObjectiveProgrammableProblemEvaluator : IMultiObjectiveEvaluator {
+    ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
+    ILookupParameter<Encoding> EncodingParameter { get; }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IProblemDefinition.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IProblemDefinition.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/IProblemDefinition.cs	(revision 11572)
@@ -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;
+using System.Collections.Generic;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.Programmable {
+  public interface IProblemDefinition : INamedItem {
+    Encoding Encoding { get; }
+    IEnumerable<Individual> GetNeighbors(IRandom random, Individual individual);
+
+    event EventHandler ProblemDefinitionChanged;
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveMoveOperator.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveMoveOperator.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveMoveOperator.cs	(revision 11572)
@@ -0,0 +1,6 @@
+﻿using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.Programmable {
+  public interface ISingleObjectiveMoveOperator : IMoveOperator {
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 11572)
@@ -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.Problems.Programmable {
+  public interface ISingleObjectiveProblemDefinition : IProblemDefinition {
+    bool IsMaximizationProblem { get; }
+    double Evaluate(IRandom random, Individual individual);
+    void Analyze(Individual[] individuals, double[] qualities, ResultCollection results);
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemAnalyzer.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemAnalyzer.cs	(revision 11572)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.Programmable {
+  public interface ISingleObjectiveProgrammableProblemAnalyzer : IAnalyzer {
+    ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
+    ILookupParameter<Encoding> EncodingParameter { get; }
+    IScopeTreeLookupParameter<DoubleValue> QualityParameter { get; }
+    ILookupParameter<ResultCollection> ResultsParameter { get; }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemEvaluator.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemEvaluator.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemEvaluator.cs	(revision 11572)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.Programmable {
+  public interface ISingleObjectiveProgrammableProblemEvaluator : ISingleObjectiveEvaluator {
+    ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
+    ILookupParameter<Encoding> EncodingParameter { get; }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinition.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinition.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinition.cs	(revision 11572)
@@ -0,0 +1,42 @@
+﻿#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", "Base class for custom multi-objective problem definitions.")]
+  public abstract class MultiObjectiveProblemDefinition : ProblemDefinition, IMultiObjectiveProblemDefinition {
+
+    public abstract bool[] Maximization { get; }
+    public abstract double[] Evaluate(IRandom random, Individual vector);
+    public virtual void Analyze(Individual[] vectors, double[][] qualities, ResultCollection results) { }
+
+    [StorableConstructor]
+    protected MultiObjectiveProblemDefinition(bool deserializing) : base(deserializing) { }
+    protected MultiObjectiveProblemDefinition(MultiObjectiveProblemDefinition original, Cloner cloner) : base(original, cloner) { }
+    protected MultiObjectiveProblemDefinition(Encoding encoding) : this(encoding, "MultiObjectiveProblemDefinition", null) { }
+    protected MultiObjectiveProblemDefinition(Encoding encoding, string name) : this(encoding, name, null) { }
+    protected MultiObjectiveProblemDefinition(Encoding encoding, string name, string description) : base(encoding, name, description) { }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemScript.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemScript.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemScript.cs	(revision 11572)
@@ -0,0 +1,148 @@
+﻿#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.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 MultiObjectiveProblemScript : ProblemScript, IMultiObjectiveProblemDefinition, IStorableContent {
+    public string Filename { get; set; }
+
+    protected override string CodeTemplate {
+      get {
+        return @"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;
+
+public class CustomProblemDefinition : ProblemScriptBase, IMultiObjectiveProblemDefinition {
+  public bool[] Maximization { get { return new [] { false, false }; } }
+
+  public CustomProblemDefinition() {
+    // Define the solution encoding which can also consist of multiple vectors, examples below
+    // Encoding = new BinaryEncoding(""b"", length: 5);
+    // Encoding = new IntegerEncoding(""i"", lenght: 5, min: 2, max: 14, step: 4);
+    // Encoding = new RealEncoding(""r"", length: 5, min: -1.0, max: 1.0);
+    // Encoding = new PermutationEncoding(""P"", length: 5, type: PermutationTypes.Absolute);
+    // Encoding = new MultiEncoding()
+      // .AddBinaryVector(""b"", length: 5)
+      // .AddIntegerVector(""i"", length: 5, min: 2, max: 14, step: 4)
+      // .AddRealVector(""r"", length: 5, min: -1.0, max: 1.0)
+      // .AddPermutation(""P"", length: 5, type: PermutationTypes.Absolute)
+    ;
+  }
+
+  public override void Initialize() {
+    // when the definition is created here you can initialize variables in the variable store
+  }
+
+  public double[] Evaluate(IRandom random, Individual individual) {
+    var qualities = new [] { 0.0, 0.0 };
+    // use vars.yourVariable to access variables in the variable store i.e. yourVariable
+    // 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) {
+    // write or update results given the range of vectors and resulting qualities
+    // use e.g. vars.yourVariable to access variables in the variable store i.e. yourVariable
+  }
+
+  public override IEnumerable<Individual> GetNeighbors(IRandom random, Individual individual) {
+    // Create new vectors, based on the given one that represent small changes
+    // This method is only called from move-based algorithms (LocalSearch, SimulatedAnnealing, etc.)
+    while (true) {
+      // this is not an infinite loop as only a finite amount of samples will be drawn
+      // it is possible to return a concrete amount of neighbors also
+      var neighbor = (Individual)individual.Clone();
+      //e.g. make a 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
+}";
+      }
+    }
+
+    [StorableConstructor]
+    protected MultiObjectiveProblemScript(bool deserializing) : base(deserializing) { }
+    protected MultiObjectiveProblemScript(MultiObjectiveProblemScript original, Cloner cloner)
+      : base(original, cloner) { }
+
+    public MultiObjectiveProblemScript() {
+      Code = CodeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveProblemScript(this, cloner);
+    }
+
+    public new IMultiObjectiveProblemDefinition Instance {
+      get { return (IMultiObjectiveProblemDefinition)base.Instance; }
+      protected set { base.Instance = value; }
+    }
+
+    protected override void OnInstanceChanged() {
+      OnProblemDefinitionChanged();
+      base.OnInstanceChanged();
+    }
+
+    bool[] IMultiObjectiveProblemDefinition.Maximization {
+      get { return Instance != null ? Instance.Maximization : new bool[0]; }
+    }
+
+    Encoding IProblemDefinition.Encoding {
+      get { return Instance != null ? Instance.Encoding : null; }
+    }
+
+    double[] IMultiObjectiveProblemDefinition.Evaluate(IRandom random, Individual individual) {
+      return Instance.Evaluate(random, individual);
+    }
+
+    void IMultiObjectiveProblemDefinition.Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
+      Instance.Analyze(individuals, qualities, results);
+    }
+
+    IEnumerable<Individual> IProblemDefinition.GetNeighbors(IRandom random, Individual individual) {
+      return Instance.GetNeighbors(random, individual);
+    }
+
+    public event EventHandler ProblemDefinitionChanged;
+    private void OnProblemDefinitionChanged() {
+      var handler = ProblemDefinitionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 11572)
@@ -0,0 +1,857 @@
+﻿#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.Drawing;
+using System.Linq;
+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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("Programmable Problem (multi-objective)", "Represents a multi-objective problem that can be programmed.")]
+  [Creatable("Problems")]
+  [StorableClass]
+  public class MultiObjectiveProgrammableProblem : MultiObjectiveHeuristicOptimizationProblem<IMultiObjectiveProgrammableProblemEvaluator, ISolutionCreator>, IParameterizedNamedItem, IStorableContent {
+    public string Filename { get; set; }
+
+    public static new Image StaticItemImage {
+      get { return Common.Resources.VSImageLibrary.Script; }
+    }
+
+    public new ParameterCollection Parameters {
+      get { return base.Parameters; }
+    }
+    IKeyedItemCollection<string, IParameter> IParameterizedItem.Parameters {
+      get { return Parameters; }
+    }
+
+    public IValueParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (IValueParameter<IMultiObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+
+    protected IValueParameter<Encoding> EncodingParameter {
+      get { return (IValueParameter<Encoding>)Parameters["Encoding"]; }
+    }
+
+    public IMultiObjectiveProblemDefinition ProblemDefinition {
+      get { return ProblemDefinitionParameter.Value; }
+      set { ProblemDefinitionParameter.Value = value; }
+    }
+
+    [Storable]
+    protected List<IParameter> DynamicEncodingParameters;
+
+    [StorableConstructor]
+    protected MultiObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
+    protected MultiObjectiveProgrammableProblem(MultiObjectiveProgrammableProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DynamicEncodingParameters = original.DynamicEncodingParameters.Select(cloner.Clone).ToList();
+      RegisterEventHandlers();
+    }
+    public MultiObjectiveProgrammableProblem()
+      : base(new MultiObjectiveEvaluator(), new MultiEncodingCreator()) {
+      Parameters.Add(new ValueParameter<IMultiObjectiveProblemDefinition>("ProblemDefinition", "Defines the problem.", new MultiObjectiveProblemScript() { Name = Name }));
+      Parameters.Add(new ValueParameter<Encoding>("Encoding", "Describes which parameters exist, what they're called, what type they are and their bounds if any."));
+
+      DynamicEncodingParameters = new List<IParameter>();
+
+      Operators.Add(new MultiObjectiveAnalyzer());
+      Operators.Add(Evaluator);
+      Operators.Add(SolutionCreator);
+
+      RegisterEventHandlers();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveProgrammableProblem(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    // ReSharper disable UnusedMember.Local
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+    // ReSharper restore UnusedMember.Local
+
+    private void RegisterEventHandlers() {
+      ProblemDefinitionParameter.ValueChanged += ProblemDefinitionParameterOnValueChanged;
+      RegisterHostInstanceChanges();
+    }
+
+    private void ProblemDefinitionParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      RegisterHostInstanceChanges();
+      Parameterize();
+    }
+
+    private void RegisterHostInstanceChanges() {
+      ProblemDefinitionParameter.Value.ProblemDefinitionChanged += ProblemDefinitionChanged;
+      ProblemDefinitionParameter.Value.NameChanged += ProblemDefinitionHostOnNameChanged;
+    }
+
+    private void ProblemDefinitionHostOnNameChanged(object sender, EventArgs eventArgs) {
+      if (sender != ProblemDefinitionParameter.Value) return;
+      Name = ProblemDefinitionParameter.Value.Name;
+    }
+
+    protected override void OnNameChanged() {
+      base.OnNameChanged();
+      ProblemDefinitionParameter.Value.Name = Name;
+    }
+
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      Parameterize();
+    }
+
+    protected virtual void ProblemDefinitionChanged(object sender, EventArgs eventArgs) {
+      Parameterize();
+    }
+
+    protected virtual void Parameterize() {
+      var definition = ProblemDefinitionParameter.Value;
+      if (definition == null) return;
+
+      Encoding encoding;
+      try {
+        encoding = definition.Encoding;
+      } catch { return; }
+      EncodingParameter.Value = encoding;
+      Maximization = new BoolArray(definition.Maximization);
+
+      Evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
+      Evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      foreach (var evalOp in Operators.OfType<IMultiObjectiveProgrammableProblemEvaluator>()) {
+        evalOp.EncodingParameter.ActualName = EncodingParameter.Name;
+        evalOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      }
+      foreach (var analyzeOp in Operators.OfType<IMultiObjectiveProgrammableProblemAnalyzer>()) {
+        analyzeOp.EncodingParameter.ActualName = EncodingParameter.Name;
+        analyzeOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+        analyzeOp.QualitiesParameter.ActualName = Evaluator.QualitiesParameter.ActualName;
+      }
+
+      foreach (var param in DynamicEncodingParameters)
+        if (Parameters.Contains(param)) Parameters.Remove(param);
+      DynamicEncodingParameters.Clear();
+
+      var creator = ConfigureCreator(encoding);
+
+      foreach (var param in DynamicEncodingParameters) {
+        param.Hidden = true;
+        Parameters.Add(param);
+      }
+
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        ConfigureMultiVectorEncodingOperators((MultiEncodingCreator)creator, multiEncoding);
+      } else {
+        ConfigureSingleEncodingOperators(creator, encoding);
+      }
+    }
+
+    protected virtual ISolutionCreator ConfigureCreator(Encoding encoding) {
+      #region Configure MultiEncoding Creator
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        var creator = new MultiEncodingCreator();
+        foreach (var enc in multiEncoding.Encodings) {
+          if (enc is MultiEncoding) throw new InvalidOperationException("MultiEncoding within a MultiEncoding is not supported.");
+          creator.Operators.Add(ConfigureCreator(enc));
+        }
+        return creator;
+      }
+      #endregion
+      #region Configure BinaryVector Creator
+      var binEnc = encoding as BinaryEncoding;
+      if (binEnc != null) {
+        var p = new ValueParameter<IntValue>(binEnc.Name + "Length", binEnc.Length);
+        DynamicEncodingParameters.Add(p);
+
+        var creator = new RandomBinaryVectorCreator();
+        creator.BinaryVectorParameter.ActualName = binEnc.Name;
+        creator.LengthParameter.ActualName = p.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure IntegerVector Creator
+      var intEnc = encoding as IntegerEncoding;
+      if (intEnc != null) {
+        var l = new ValueParameter<IntValue>(intEnc.Name + "Length", intEnc.Length);
+        var b = new ValueParameter<IntMatrix>(intEnc.Name + "Bounds", intEnc.Bounds);
+        DynamicEncodingParameters.Add(l);
+        DynamicEncodingParameters.Add(b);
+
+        var creator = new UniformRandomIntegerVectorCreator();
+        creator.IntegerVectorParameter.ActualName = intEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.BoundsParameter.ActualName = b.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure RealVector Creator
+      var realEnc = encoding as RealEncoding;
+      if (realEnc != null) {
+        var l = new ValueParameter<IntValue>(realEnc.Name + "Length", realEnc.Length);
+        var b = new ValueParameter<DoubleMatrix>(realEnc.Name + "Bounds", realEnc.Bounds);
+        DynamicEncodingParameters.Add(l);
+        DynamicEncodingParameters.Add(b);
+
+        var creator = new UniformRandomRealVectorCreator();
+        creator.RealVectorParameter.ActualName = realEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.BoundsParameter.ActualName = b.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure Permutation Creator
+      var permEnc = encoding as PermutationEncoding;
+      if (permEnc != null) {
+        var l = new ValueParameter<IntValue>(permEnc.Name + "Length", permEnc.Length);
+        DynamicEncodingParameters.Add(l);
+
+        var creator = new RandomPermutationCreator();
+        creator.PermutationParameter.ActualName = permEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.PermutationTypeParameter.Value = permEnc.Type;
+        return creator;
+      }
+      #endregion
+      throw new ArgumentException(string.Format("Encoding {0} is unknown.", encoding != null ? encoding.GetType().FullName : "(null)"));
+    }
+
+    protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, Encoding encoding) {
+      // remove all multiencoding operators
+      Operators.RemoveAll(x => x is MultiEncodingCrossover
+                            || x is MultiEncodingManipulator
+                            || x is MultiEncodingCreator);
+
+      #region Configure Operators for BinaryVectorEncoding
+      var binCreator = newCreator as IBinaryVectorCreator;
+      if (binCreator != null) {
+        var paramName = binCreator.BinaryVectorParameter.ActualName;
+        // do not replace a binary vector creator that was manually set
+        if (!(SolutionCreator is IBinaryVectorCreator) || ((IBinaryVectorCreator)SolutionCreator).BinaryVectorParameter.ActualName != paramName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+
+        #region Wire BinaryVector Crossovers
+        var crossovers = Operators.OfType<IBinaryVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>(), new TypeEqualityComparer<IBinaryVectorCrossover>())
+          .ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
+          xo.ChildParameter.Hidden = true;
+          xo.ParentsParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
+          xo.ParentsParameter.Hidden = true;
+        }
+        Operators.AddRange(crossovers.Except(Operators.OfType<IBinaryVectorCrossover>()));
+        #endregion
+        #region Wire BinaryVector Manipulators
+        var manipulators = Operators.OfType<IBinaryVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>(), new TypeEqualityComparer<IBinaryVectorManipulator>())
+          .ToList();
+        foreach (var m in manipulators) {
+          m.BinaryVectorParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
+          m.BinaryVectorParameter.Hidden = true;
+        }
+        Operators.AddRange(manipulators.Except(Operators.OfType<IBinaryVectorManipulator>()));
+        #endregion
+        #region Wire BinaryVector ShakingOperators
+        var shakingOperators = Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IBinaryVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
+        foreach (var so in shakingOperators) {
+          so.BinaryVectorParameter.ActualName = paramName;
+          so.BinaryVectorParameter.Hidden = true;
+        }
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()));
+        #endregion
+      } else {
+        Operators.RemoveAll(x => x is IBinaryVectorCrossover
+          || x is IBinaryVectorManipulator
+          || x is IBinaryVectorMultiNeighborhoodShakingOperator);
+      }
+      #endregion
+      #region Configure Operators for IntegerVectorEncoding
+      var intCreator = newCreator as IIntegerVectorCreator;
+      if (intCreator != null) {
+        var paramName = intCreator.IntegerVectorParameter.ActualName;
+        // do not replace an integer vector creator that was manually set
+        if (!(SolutionCreator is IIntegerVectorCreator)
+          || ((IIntegerVectorCreator)SolutionCreator).IntegerVectorParameter.ActualName != intCreator.IntegerVectorParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+
+        #region Wire IntegerVector Crossovers
+        var crossovers = Operators.OfType<IIntegerVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>(), new TypeEqualityComparer<IIntegerVectorCrossover>())
+          .ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
+          xo.ChildParameter.Hidden = true;
+          xo.ParentsParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
+          xo.ParentsParameter.Hidden = true;
+          var bx = xo as IBoundedIntegerVectorOperator;
+          if (bx != null) {
+            bx.BoundsParameter.ActualName = intCreator.BoundsParameter.ActualName;
+            bx.BoundsParameter.Hidden = true;
+          }
+        }
+        Operators.AddRange(crossovers.Except(Operators.OfType<IIntegerVectorCrossover>()));
+        #endregion
+        #region Wire IntegerVector Manipulators
+        var manipulators = Operators.OfType<IIntegerVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>(), new TypeEqualityComparer<IIntegerVectorManipulator>())
+          .ToList();
+        foreach (var m in manipulators) {
+          m.IntegerVectorParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
+          m.IntegerVectorParameter.Hidden = true;
+          var sm = m as ISelfAdaptiveManipulator;
+          if (sm != null) {
+            var p = sm.StrategyParameterParameter as ILookupParameter;
+            if (p != null) {
+              p.ActualName = paramName + "Strategy";
+              p.Hidden = true;
+            }
+          }
+          var bm = m as IBoundedIntegerVectorOperator;
+          if (bm != null) {
+            bm.BoundsParameter.ActualName = intCreator.BoundsParameter.ActualName;
+            bm.BoundsParameter.Hidden = true;
+          }
+        }
+        Operators.AddRange(manipulators.Except(Operators.OfType<IIntegerVectorManipulator>()));
+        #region Wire IntegerVector StrategyParameters for SelfAdaptiveManipulators
+        var strategyOperators = Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IIntegerVectorStdDevStrategyParameterOperator>())
+          .ToList();
+        var problemSize = ((IntegerEncoding)encoding).Length.Value;
+        var b = ((IntegerEncoding)encoding).Bounds;
+        var bounds = new DoubleMatrix(b.Rows, b.Columns);
+        for (var i = 0; i < bounds.Rows; i++) {
+          bounds[i, 1] = (int)Math.Ceiling(0.33 * (b[i, 1] - b[i, 0]));
+          bounds[i, 0] = 0;
+          if (bounds.Columns > 2) bounds[i, 2] = b[i, 2];
+        }
+        foreach (var s in strategyOperators) {
+          var c = s as IIntegerVectorStdDevStrategyParameterCreator;
+          if (c != null) {
+            c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+            c.LengthParameter.ActualName = intCreator.LengthParameter.ActualName;
+            c.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+          var m = s as IIntegerVectorStdDevStrategyParameterManipulator;
+          if (m != null) {
+            m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+            m.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+          var mm = s as Encodings.IntegerVectorEncoding.StdDevStrategyVectorManipulator;
+          if (mm != null) {
+            mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * problemSize));
+            mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(problemSize)));
+          }
+          var x = s as IIntegerVectorStdDevStrategyParameterCrossover;
+          if (x != null) {
+            x.ParentsParameter.ActualName = paramName + "Strategy";
+            x.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+        }
+        Operators.AddRange(strategyOperators.Except(Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()));
+        #endregion
+        #endregion
+        #region Wire IntegerVector ShakingOperators
+        var shakingOperators = Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IIntegerVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
+        foreach (var so in shakingOperators) {
+          so.IntegerVectorParameter.ActualName = paramName;
+          so.IntegerVectorParameter.Hidden = true;
+        }
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()));
+        #endregion
+      } else {
+        Operators.RemoveAll(x => x is IIntegerVectorCrossover
+          || x is IIntegerVectorManipulator
+          || x is IIntegerVectorStdDevStrategyParameterOperator
+          || x is IIntegerVectorMultiNeighborhoodShakingOperator);
+      }
+      #endregion
+      #region Configure Operators for RealVectorEncoding
+      var realCreator = newCreator as IRealVectorCreator;
+      if (realCreator != null) {
+        var paramName = realCreator.RealVectorParameter.ActualName;
+        // do not replace a real vector creator that was manually set
+        if (!(SolutionCreator is IRealVectorCreator)
+            || ((IRealVectorCreator)SolutionCreator).RealVectorParameter.ActualName != realCreator.RealVectorParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+
+        #region Wire RealVector Crossovers
+        var crossovers = Operators.OfType<IRealVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorCrossover>(), new TypeEqualityComparer<IRealVectorCrossover>())
+          .ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = paramName;
+          xo.ChildParameter.Hidden = true;
+          xo.ParentsParameter.ActualName = paramName;
+          xo.ParentsParameter.Hidden = true;
+          xo.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+          xo.BoundsParameter.Hidden = true;
+        }
+        Operators.AddRange(crossovers.Except(Operators.OfType<IRealVectorCrossover>()));
+        #endregion
+        #region Wire RealVector Manipulators
+        var manipulators = Operators.OfType<IRealVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorManipulator>(), new TypeEqualityComparer<IRealVectorManipulator>())
+          .ToList();
+        foreach (var m in manipulators) {
+          m.RealVectorParameter.ActualName = paramName;
+          m.RealVectorParameter.Hidden = true;
+          m.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+          m.BoundsParameter.Hidden = true;
+          var sm = m as ISelfAdaptiveManipulator;
+          if (sm != null) {
+            var p = sm.StrategyParameterParameter as ILookupParameter;
+            if (p != null) {
+              p.ActualName = paramName + "Strategy";
+              p.Hidden = true;
+            }
+          }
+        }
+        Operators.AddRange(manipulators.Except(Operators.OfType<IRealVectorManipulator>()));
+        #region Wire RealVector Strategy Parameters for SelfAdaptiveManipulators
+        var strategyOperators = Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IRealVectorStdDevStrategyParameterOperator>())
+          .ToList();
+        var problemSize = ((RealEncoding)encoding).Length.Value;
+        var bounds = (DoubleMatrix)((RealEncoding)encoding).Bounds.Clone();
+        for (var i = 0; i < bounds.Rows; i++) {
+          bounds[i, 1] = 0.1 * (bounds[i, 1] - bounds[i, 0]);
+          bounds[i, 0] = 0;
+        }
+        foreach (var s in strategyOperators) {
+          var c = s as IRealVectorStdDevStrategyParameterCreator;
+          if (c != null) {
+            c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+            c.LengthParameter.ActualName = realCreator.LengthParameter.ActualName;
+            c.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+          var m = s as IRealVectorStdDevStrategyParameterManipulator;
+          if (m != null) {
+            m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+            m.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+          var mm = s as Encodings.RealVectorEncoding.StdDevStrategyVectorManipulator;
+          if (mm != null) {
+            mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * problemSize));
+            mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(problemSize)));
+          }
+          var x = s as IRealVectorStdDevStrategyParameterCrossover;
+          if (x != null) {
+            x.ParentsParameter.ActualName = paramName + "Strategy";
+            x.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+        }
+        Operators.AddRange(strategyOperators.Except(Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()));
+        #endregion
+        #endregion
+        #region Wire RealVector ParticleCreators
+        var particleCreators = Operators.OfType<IRealVectorParticleCreator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleCreator>(), new TypeEqualityComparer<IRealVectorParticleCreator>())
+          .ToList();
+        foreach (var pc in particleCreators) {
+          pc.RealVectorParameter.ActualName = paramName;
+          pc.RealVectorParameter.Hidden = true;
+          pc.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+          pc.BoundsParameter.Hidden = true;
+          pc.ProblemSizeParameter.ActualName = realCreator.LengthParameter.ActualName;
+          pc.ProblemSizeParameter.Hidden = true;
+        }
+        Operators.AddRange(particleCreators.Except(Operators.OfType<IRealVectorParticleCreator>()));
+        #endregion
+        #region Wire RealVector ParticleUpdaters
+        var particleUpdaters = Operators.OfType<IRealVectorParticleUpdater>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleUpdater>(), new TypeEqualityComparer<IRealVectorParticleUpdater>())
+          .ToList();
+        foreach (var pu in particleUpdaters) {
+          pu.RealVectorParameter.ActualName = paramName;
+          pu.RealVectorParameter.Hidden = true;
+          pu.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+          pu.BoundsParameter.Hidden = true;
+        }
+        Operators.AddRange(particleUpdaters.Except(Operators.OfType<IRealVectorParticleUpdater>()));
+        #endregion
+        #region Wire RealVector SwarmUpdaters
+        var swarmUpdaters = Operators.OfType<IRealVectorSwarmUpdater>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorSwarmUpdater>(), new TypeEqualityComparer<IRealVectorSwarmUpdater>())
+          .ToList();
+        foreach (var su in swarmUpdaters) {
+          su.RealVectorParameter.ActualName = paramName;
+          su.RealVectorParameter.Hidden = true;
+          su.MaximizationParameter.ActualName = MaximizationParameter.Name;
+          su.MaximizationParameter.Hidden = true;
+        }
+        Operators.AddRange(swarmUpdaters.Except(Operators.OfType<IRealVectorSwarmUpdater>()));
+        #endregion
+        #region Wire RealVector ShakingOperators
+        var shakingOperators = Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IRealVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
+        foreach (var so in shakingOperators) {
+          so.RealVectorParameter.ActualName = paramName;
+          so.RealVectorParameter.Hidden = true;
+        }
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()));
+        #endregion
+      } else {
+        Operators.RemoveAll(x => x is IRealVectorCrossover
+          || x is IRealVectorManipulator
+          || x is IRealVectorStdDevStrategyParameterOperator
+          || x is IRealVectorParticleCreator
+          || x is IRealVectorParticleUpdater
+          || x is IRealVectorSwarmUpdater
+          || x is IRealVectorMultiNeighborhoodShakingOperator);
+      }
+      #endregion
+      #region Configure Operators for PermutationEncoding
+      var permCreator = newCreator as IPermutationCreator;
+      if (permCreator != null) {
+        var paramName = permCreator.PermutationParameter.ActualName;
+        // do not replace a permutation creator that was manually set
+        if (!(SolutionCreator is IPermutationCreator)
+            || ((IPermutationCreator)SolutionCreator).PermutationParameter.ActualName != permCreator.PermutationParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+
+        #region Wire Permutation Crossovers
+        var crossovers = Operators.OfType<IPermutationCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationCrossover>(), new TypeEqualityComparer<IPermutationCrossover>())
+          .ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = permCreator.PermutationParameter.ActualName;
+          xo.ChildParameter.Hidden = true;
+          xo.ParentsParameter.ActualName = permCreator.PermutationParameter.ActualName;
+          xo.ParentsParameter.Hidden = true;
+        }
+        Operators.AddRange(crossovers.Except(Operators.OfType<IPermutationCrossover>()));
+        #endregion
+        #region Wire Permutation Manipulators
+        var manipulators = Operators.OfType<IPermutationManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationManipulator>(), new TypeEqualityComparer<IPermutationManipulator>())
+          .ToList();
+        foreach (var m in manipulators) {
+          m.PermutationParameter.ActualName = permCreator.PermutationParameter.ActualName;
+          m.PermutationParameter.Hidden = true;
+        }
+        Operators.AddRange(manipulators.Except(Operators.OfType<IPermutationManipulator>()));
+        #endregion
+        #region Wire Permutation ShakingOperators
+        var shakingOperators = Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IPermutationMultiNeighborhoodShakingOperator>())
+          .ToList();
+        foreach (var op in shakingOperators) {
+          op.PermutationParameter.ActualName = paramName;
+          op.PermutationParameter.Hidden = true;
+        }
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()));
+        #endregion
+      } else {
+        Operators.RemoveAll(x => x is IPermutationCrossover
+          || x is IPermutationManipulator
+          || x is IPermutationMultiNeighborhoodShakingOperator);
+      }
+      #endregion
+    }
+
+    protected virtual void ConfigureMultiVectorEncodingOperators(MultiEncodingCreator newCreator, MultiEncoding encoding) {
+      var newBinParams = new HashSet<string>(newCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
+      var newIntParams = new HashSet<string>(newCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
+      var newRealParams = new HashSet<string>(newCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
+      var newPermParams = new HashSet<string>(newCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
+
+      var oldCreator = SolutionCreator as MultiEncodingCreator;
+      if (oldCreator == null) SolutionCreator = newCreator;
+      else {
+        #region Configure BinaryVector Creator
+        var oldBinParams = new HashSet<string>(oldCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
+        foreach (var toAdd in newBinParams.Except(oldBinParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IBinaryVectorCreator>().Single(x => x.BinaryVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+          var op = oldCreator.Operators.OfType<IBinaryVectorCreator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+        #endregion
+
+        #region Configure IntegerVector Creator
+        var oldIntParams = new HashSet<string>(oldCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
+        foreach (var toAdd in newIntParams.Except(oldIntParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IIntegerVectorCreator>().Single(x => x.IntegerVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+          var op = oldCreator.Operators.OfType<IIntegerVectorCreator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+        #endregion
+
+        #region Configure RealVector Creator
+        var oldRealParams = new HashSet<string>(oldCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
+        foreach (var toAdd in newRealParams.Except(oldRealParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IRealVectorCreator>().Single(x => x.RealVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+          var op = oldCreator.Operators.OfType<IRealVectorCreator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+        #endregion
+
+        #region Configure Permutation Creator
+        var oldPermParams = new HashSet<string>(oldCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
+        foreach (var toAdd in newPermParams.Except(oldPermParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+          var op = oldCreator.Operators.OfType<IPermutationCreator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+        // we also have to sync the permutation type (in case this changes, as it is a value parameter)
+        foreach (var intersect in newPermParams.Intersect(oldPermParams)) {
+          var oldPermCreator = oldCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
+          var newPermCreator = newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
+          oldPermCreator.PermutationTypeParameter.Value = newPermCreator.PermutationTypeParameter.Value;
+        }
+        #endregion
+
+      }
+
+      // crossover and manipulator for multi-vector encoding
+      // the condition checks if a multi-vector encoding is to be updated (there already exists ParameterVectorCrossover and ParameterVectorManipulator)
+      if (Operators.OfType<MultiEncodingCrossover>().Any() && Operators.OfType<MultiEncodingManipulator>().Any()) {
+        #region Update existing multi-vector encoding
+        #region Update ParameterVector Crossover ...
+        foreach (var oldXo in Operators.OfType<MultiEncodingCrossover>()) {
+          #region ... for binary parameters
+          var oldBinParams = new HashSet<string>(oldXo.Operators.OfType<IBinaryVectorCrossover>().Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newBinParams.Except(oldBinParams))
+            oldXo.Operators.Add(GetDefaultBinaryCrossover(toAdd, encoding));
+          foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op = oldXo.Operators.OfType<IBinaryVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for integer parameters
+          var oldIntParams = new HashSet<string>(oldXo.Operators.OfType<IIntegerVectorCrossover>().Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newIntParams.Except(oldIntParams))
+            oldXo.Operators.Add(GetDefaultIntegerCrossover(toAdd, encoding));
+          foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op = oldXo.Operators.OfType<IIntegerVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for real parameters
+          var oldRealParams = new HashSet<string>(oldXo.Operators.OfType<IRealVectorCrossover>().Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newRealParams.Except(oldRealParams))
+            oldXo.Operators.Add(GetDefaultRealCrossover(toAdd, encoding));
+          foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op = oldXo.Operators.OfType<IRealVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for permutation parameters
+          var oldPermParams = new HashSet<string>(oldXo.Operators.OfType<IPermutationCrossover>().Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newPermParams.Except(oldPermParams))
+            oldXo.Operators.Add(GetDefaultPermutationCrossover(toAdd, encoding));
+          foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op = oldXo.Operators.OfType<IPermutationCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+          #endregion
+        }
+        #endregion
+        #region Update ParameterVector Manipulator ...
+        foreach (var oldM in Operators.OfType<MultiEncodingManipulator>()) {
+          #region ... for binary parameters
+          var oldBinParams = new HashSet<string>(oldM.Operators.OfType<IBinaryVectorManipulator>().Select(x => x.BinaryVectorParameter.ActualName));
+          foreach (var toAdd in newBinParams.Except(oldBinParams))
+            oldM.Operators.Add(GetDefaultBinaryManipulator(toAdd, encoding));
+          foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op = oldM.Operators.OfType<IBinaryVectorManipulator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for integer parameters
+          var oldIntParams = new HashSet<string>(oldM.Operators.OfType<IIntegerVectorManipulator>().Select(x => x.IntegerVectorParameter.ActualName));
+          foreach (var toAdd in newIntParams.Except(oldIntParams))
+            oldM.Operators.Add(GetDefaultIntegerManipulator(toAdd, encoding));
+          foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op = oldM.Operators.OfType<IIntegerVectorManipulator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for real parameters
+          var oldRealParams = new HashSet<string>(oldM.Operators.OfType<IRealVectorManipulator>().Select(x => x.RealVectorParameter.ActualName));
+          foreach (var toAdd in newRealParams.Except(oldRealParams))
+            oldM.Operators.Add(GetDefaultRealManipulator(toAdd, encoding));
+          foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op = oldM.Operators.OfType<IRealVectorManipulator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for permutation parameters
+          var oldPermParams = new HashSet<string>(oldM.Operators.OfType<IPermutationManipulator>().Select(x => x.PermutationParameter.ActualName));
+          foreach (var toAdd in newPermParams.Except(oldPermParams))
+            oldM.Operators.Add(GetDefaultPermutationManipulator(toAdd, encoding));
+          foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op = oldM.Operators.OfType<IPermutationManipulator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+          #endregion
+        }
+        #endregion
+        #endregion
+      } else {
+        #region Handle transition from single-vector to multi-vector encoding
+        Operators.RemoveAll(x => x is ICrossover);
+        Operators.RemoveAll(x => x is IManipulator);
+        Operators.RemoveAll(x => x is IStrategyParameterCreator || x is IStrategyParameterManipulator || x is IStrategyParameterCrossover);
+        Operators.RemoveAll(x => x is IParticleCreator);
+        Operators.RemoveAll(x => x is IParticleUpdater);
+        Operators.RemoveAll(x => x is ISwarmUpdater);
+        Operators.RemoveAll(x => x is IMultiNeighborhoodShakingOperator);
+
+        var crossover = new MultiEncodingCrossover();
+        var manipulator = new MultiEncodingManipulator();
+        foreach (var enc in encoding.Encodings) {
+          if (enc is BinaryEncoding) {
+            crossover.Operators.Add(GetDefaultBinaryCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultBinaryManipulator(enc.Name, encoding));
+            continue;
+          }
+          var intConfig = enc as IntegerEncoding;
+          if (intConfig != null) {
+            crossover.Operators.Add(GetDefaultIntegerCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultIntegerManipulator(enc.Name, encoding));
+            continue;
+          }
+          var realConfig = enc as RealEncoding;
+          if (realConfig != null) {
+            crossover.Operators.Add(GetDefaultRealCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultRealManipulator(enc.Name, encoding));
+            continue;
+          }
+          var permConfig = enc as PermutationEncoding;
+          if (permConfig != null) {
+            crossover.Operators.Add(GetDefaultPermutationCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultPermutationManipulator(enc.Name, encoding));
+            continue;
+          }
+          throw new InvalidOperationException("Unknown type for parameter " + enc.Name);
+        }
+        Operators.Add(crossover);
+        Operators.Add(manipulator);
+        #endregion
+      }
+    }
+
+    #region GetDefaultOperators for Crossovers and Manipulators
+    // ReSharper disable RedundantNameQualifier
+    protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, MultiEncoding config) {
+      var binConfig = (BinaryEncoding)config.Encodings[paramName];
+      IBinaryVectorCrossover binXo;
+      if (binConfig.Length.Value > 3) binXo = new Encodings.BinaryVectorEncoding.SinglePointCrossover();
+      else binXo = new Encodings.BinaryVectorEncoding.UniformCrossover();
+      binXo.ChildParameter.ActualName = paramName;
+      binXo.ParentsParameter.ActualName = paramName;
+      return binXo;
+    }
+
+    protected virtual IBinaryVectorManipulator GetDefaultBinaryManipulator(string paramName, MultiEncoding config) {
+      var binM = new Encodings.BinaryVectorEncoding.SomePositionsBitflipManipulator();
+      binM.BinaryVectorParameter.ActualName = paramName;
+      binM.MutationProbabilityParameter.Value = new DoubleValue(0.1);
+      return binM;
+    }
+
+    protected virtual IIntegerVectorCrossover GetDefaultIntegerCrossover(string paramName, MultiEncoding config) {
+      var intXo = new Encodings.IntegerVectorEncoding.RoundedBlendAlphaCrossover();
+      intXo.ChildParameter.ActualName = paramName;
+      intXo.ParentsParameter.ActualName = paramName;
+      intXo.BoundsParameter.ActualName = paramName + "Bounds";
+      return intXo;
+    }
+
+    protected virtual IIntegerVectorManipulator GetDefaultIntegerManipulator(string paramName, MultiEncoding configuration) {
+      var intM = new Encodings.IntegerVectorEncoding.UniformSomePositionsManipulator();
+      intM.IntegerVectorParameter.ActualName = paramName;
+      intM.BoundsParameter.ActualName = paramName + "Bounds";
+      intM.ProbabilityParameter.Value = new DoubleValue(0.1);
+      return intM;
+    }
+
+    protected virtual IRealVectorCrossover GetDefaultRealCrossover(string paramName, MultiEncoding configuration) {
+      var realXo = new Encodings.RealVectorEncoding.BlendAlphaCrossover();
+      realXo.ChildParameter.ActualName = paramName;
+      realXo.ParentsParameter.ActualName = paramName;
+      realXo.BoundsParameter.ActualName = paramName + "Bounds";
+      return realXo;
+    }
+
+    protected virtual IRealVectorManipulator GetDefaultRealManipulator(string paramName, MultiEncoding configuration) {
+      var realM = new Encodings.RealVectorEncoding.BreederGeneticAlgorithmManipulator();
+      realM.RealVectorParameter.ActualName = paramName;
+      realM.BoundsParameter.ActualName = paramName + "Bounds";
+      return realM;
+    }
+
+    protected virtual IPermutationCrossover GetDefaultPermutationCrossover(string paramName, MultiEncoding configuration) {
+      var permXo = new Encodings.PermutationEncoding.PartiallyMatchedCrossover();
+      permXo.ChildParameter.ActualName = paramName;
+      permXo.ParentsParameter.ActualName = paramName;
+      return permXo;
+    }
+
+    protected virtual IPermutationManipulator GetDefaultPermutationManipulator(string paramName, MultiEncoding configuration) {
+      var permM = new Encodings.PermutationEncoding.Swap2Manipulator();
+      permM.PermutationParameter.ActualName = paramName;
+      return permM;
+    }
+    // ReSharper restore RedundantNameQualifier
+    #endregion
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiEncodingCreator.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiEncodingCreator.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiEncodingCreator.cs	(revision 11572)
@@ -0,0 +1,48 @@
+﻿#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("MultiEncodingCreator", "Contains solution creators that together create a multiencoding.")]
+  [StorableClass]
+  public class MultiEncodingCreator : MultiOperator<ISolutionCreator>, ISolutionCreator {
+
+    [StorableConstructor]
+    protected MultiEncodingCreator(bool deserializing) : base(deserializing) { }
+    protected MultiEncodingCreator(MultiEncodingCreator original, Cloner cloner) : base(original, cloner) { }
+    public MultiEncodingCreator() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiEncodingCreator(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var baseOperations = base.InstrumentedApply();
+      return new OperationCollection(new[] { baseOperations }.Concat(Operators.Select(x => ExecutionContext.CreateOperation(x))));
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiEncodingCrossover.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiEncodingCrossover.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiEncodingCrossover.cs	(revision 11572)
@@ -0,0 +1,50 @@
+﻿#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("MultiEncoding Crossover", "Applies different crossovers to cross a multiencoding.")]
+  [StorableClass]
+  public class MultiEncodingCrossover : MultiOperator<ICrossover>, ICrossover {
+
+    [StorableConstructor]
+    protected MultiEncodingCrossover(bool deserializing) : base(deserializing) { }
+    protected MultiEncodingCrossover(MultiEncodingCrossover original, Cloner cloner)
+      : base(original, cloner) { }
+    public MultiEncodingCrossover() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiEncodingCrossover(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var baseOperations = base.InstrumentedApply();
+      return new OperationCollection(new[] { baseOperations }.Concat(Operators.Select(x => ExecutionContext.CreateOperation(x))));
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiEncodingManipulator.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiEncodingManipulator.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiEncodingManipulator.cs	(revision 11572)
@@ -0,0 +1,50 @@
+﻿#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("MultiEncoding Manipulator", "Applies different manipulators to change a multiencoding.")]
+  [StorableClass]
+  public class MultiEncodingManipulator : MultiOperator<IManipulator>, IManipulator {
+
+    [StorableConstructor]
+    protected MultiEncodingManipulator(bool deserializing) : base(deserializing) { }
+    protected MultiEncodingManipulator(MultiEncodingManipulator original, Cloner cloner)
+      : base(original, cloner) { }
+    public MultiEncodingManipulator() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiEncodingManipulator(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var baseOperations = base.InstrumentedApply();
+      return new OperationCollection(new[] { baseOperations }.Concat(Operators.Select(x => ExecutionContext.CreateOperation(x))));
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs	(revision 11572)
@@ -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.Problems.Programmable {
+  [Item("Multi-objective Analyzer", "Calls the Analyze method of the problem definition.")]
+  [StorableClass]
+  public class MultiObjectiveAnalyzer : SingleSuccessorOperator, IMultiObjectiveProgrammableProblemAnalyzer {
+    public bool EnabledByDefault { get { return true; } }
+
+    public ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<IMultiObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
+
+    public IScopeTreeLookupParameter<DoubleArray> QualitiesParameter {
+      get { return (IScopeTreeLookupParameter<DoubleArray>)Parameters["Qualities"]; }
+    }
+
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    [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<IMultiObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("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 definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null.");
+      var config = EncodingParameter.ActualValue;
+      var results = ResultsParameter.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 vectors = scopes.Select(scope => Helper.Extract(scope, config)).ToArray();
+      definition.Analyze(vectors, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results);
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveEvaluator.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveEvaluator.cs	(revision 11572)
@@ -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.Problems.Programmable {
+  [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, IMultiObjectiveProgrammableProblemEvaluator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<IMultiObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
+
+    public ILookupParameter<DoubleArray> QualitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Qualities"]; }
+    }
+
+    [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<IMultiObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("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 definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null.");
+      var config = EncodingParameter.ActualValue;
+      var vector = Helper.Extract(ExecutionContext.Scope, config);
+      QualitiesParameter.ActualValue = new DoubleArray(definition.Evaluate(random, vector));
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs	(revision 11572)
@@ -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.Problems.Programmable {
+  [Item("Single-objective Analyzer", "Calls the script's Analyze method to be able to write into the results collection.")]
+  [StorableClass]
+  public class SingleObjectiveAnalyzer : SingleSuccessorOperator, ISingleObjectiveProgrammableProblemAnalyzer {
+    public bool EnabledByDefault { get { return true; } }
+
+    public ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
+
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    [StorableConstructor]
+    protected SingleObjectiveAnalyzer(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveAnalyzer(SingleObjectiveAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveAnalyzer() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<ISingleObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("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."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null");
+      var config = EncodingParameter.ActualValue;
+      var results = ResultsParameter.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 vectors = scopes.Select(scope => Helper.Extract(scope, config)).ToArray();
+      definition.Analyze(vectors, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results);
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs	(revision 11572)
@@ -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.Problems.Programmable {
+  [Item("Single-objective Evaluator", "Calls the script's Evaluate method to get the quality value of the parameter vector.")]
+  [StorableClass]
+  public class SingleObjectiveEvaluator : SingleSuccessorOperator, ISingleObjectiveProgrammableProblemEvaluator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    [StorableConstructor]
+    protected SingleObjectiveEvaluator(bool deserializing) : base(deserializing) { }
+    protected 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<ISingleObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("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 definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null.");
+      var config = EncodingParameter.ActualValue;
+      var vector = Helper.Extract(ExecutionContext.Scope, config);
+      QualityParameter.ActualValue = new DoubleValue(definition.Evaluate(random, vector));
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveImprover.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveImprover.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveImprover.cs	(revision 11572)
@@ -0,0 +1,101 @@
+﻿using System;
+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.Problems.Programmable {
+  [Item("Single-objective Improver", "Improves a solution by calling GetNeighbors and Evaluate of the corresponding problem definition.")]
+  [StorableClass]
+  public sealed class SingleObjectiveImprover : SingleSuccessorOperator, ISingleObjectiveImprovementOperator, IStochasticOperator {
+    public IValueLookupParameter<IItem> SolutionParameter {
+      get { return new ValueLookupParameter<IItem>("notused"); }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)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"]; }
+    }
+
+    [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<ISingleObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("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 definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null.");
+      var encoding = EncodingParameter.ActualValue;
+      var maximize = MaximizationParameter.ActualValue.Value;
+      var maxAttempts = ImprovementAttemptsParameter.ActualValue.Value;
+      var sampleSize = SampleSizeParameter.ActualValue.Value;
+      var vector = Helper.Extract(ExecutionContext.Scope, encoding);
+      var quality = QualityParameter.ActualValue == null ? definition.Evaluate(random, vector) : QualityParameter.ActualValue.Value;
+
+      var count = 0;
+      for (var i = 0; i < maxAttempts; i++) {
+        Individual best = null;
+        var bestQuality = quality;
+        foreach (var neighbor in definition.GetNeighbors(random, vector).Take(sampleSize)) {
+          var q = definition.Evaluate(random, neighbor);
+          count++;
+          if (maximize && bestQuality > q || !maximize && bestQuality < q) continue;
+          best = neighbor;
+          bestQuality = q;
+        }
+        if (best == null) break;
+        vector = best;
+        quality = bestQuality;
+      }
+
+      LocalEvaluatedSolutionsParameter.ActualValue = new IntValue(count);
+      Helper.Write(ExecutionContext.Scope, vector);
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveEvaluator.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveEvaluator.cs	(revision 11572)
@@ -0,0 +1,81 @@
+﻿#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.Problems.Programmable {
+  [Item("Single-objective MoveEvaluator", "Evaluates a parameter vector that results from a move.")]
+  [StorableClass]
+  public class SingleObjectiveMoveEvaluator : InstrumentedOperator, ISingleObjectiveMoveOperator, ISingleObjectiveMoveEvaluator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+
+    [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<ISingleObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("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 InstrumentedApply() {
+      var random = RandomParameter.ActualValue;
+      var definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null.");
+      var config = EncodingParameter.ActualValue;
+      var vector = Helper.Extract(ExecutionContext.Scope, config);
+      MoveQualityParameter.ActualValue = new DoubleValue(definition.Evaluate(random, vector));
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveGenerator.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveGenerator.cs	(revision 11572)
@@ -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 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.Problems.Programmable {
+  [Item("Single-objective MoveGenerator", "Calls the GetNeighbors method of the problem definition to obtain the moves.")]
+  [StorableClass]
+  public class SingleObjectiveMoveGenerator : InstrumentedOperator, ISingleObjectiveMoveOperator, IMultiMoveGenerator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
+
+    [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<ISingleObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("Encoding", "An item that holds the problem's encoding."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveMoveGenerator(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var random = RandomParameter.ActualValue;
+      var definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null.");
+      var sampleSize = SampleSizeParameter.ActualValue.Value;
+      var encoding = EncodingParameter.ActualValue;
+      var vector = Helper.Extract(ExecutionContext.Scope, encoding);
+      var nbhood = definition.GetNeighbors(random, vector).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));
+        Helper.Write(moveScopes[i], nbhood[i]);
+      }
+      ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
+
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveMaker.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveMaker.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveMaker.cs	(revision 11572)
@@ -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.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("Single-objective MoveMaker", "Applies a move.")]
+  [StorableClass]
+  public class SingleObjectiveMoveMaker : InstrumentedOperator, ISingleObjectiveMoveOperator, IMoveMaker {
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)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<Encoding>("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;
+      Helper.Write(ExecutionContext.Scope.Parent, Helper.Extract(ExecutionContext.Scope, encoding));
+
+      if (QualityParameter.ActualValue == null) QualityParameter.ActualValue = new DoubleValue(MoveQualityParameter.ActualValue.Value);
+      else QualityParameter.ActualValue.Value = MoveQualityParameter.ActualValue.Value;
+
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Plugin.cs.frame	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Plugin.cs.frame	(revision 11572)
@@ -0,0 +1,44 @@
+﻿#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.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.Programmable {
+  [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/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/ProblemDefinition.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/ProblemDefinition.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/ProblemDefinition.cs	(revision 11572)
@@ -0,0 +1,64 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("ProblemDefinition", "Base class for problem definitions.")]
+  [StorableClass]
+  public abstract class ProblemDefinition : NamedItem, IProblemDefinition {
+    [Storable(Name = "Encoding")]
+    private Encoding encoding;
+    public Encoding Encoding {
+      get { return encoding; }
+      protected set {
+        if (encoding == value) return;
+        encoding = value;
+        OnProblemDefinitionChanged();
+      }
+    }
+
+    [StorableConstructor]
+    protected ProblemDefinition(bool deserializing) : base(deserializing) { }
+    protected ProblemDefinition(ProblemDefinition original, Cloner cloner)
+      : base(original, cloner) {
+      this.encoding = cloner.Clone(original.encoding);
+    }
+    protected ProblemDefinition(Encoding encoding) : this(encoding, "ProblemDefinition") { }
+    protected ProblemDefinition(Encoding encoding, string name) : this(encoding, name, string.Empty) { }
+    protected ProblemDefinition(Encoding encoding, string name, string description)
+      : base(name, description) {
+      Encoding = encoding;
+    }
+
+    public event EventHandler ProblemDefinitionChanged;
+    protected void OnProblemDefinitionChanged() {
+      var handler = ProblemDefinitionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public abstract IEnumerable<Individual> GetNeighbors(IRandom random, Individual vector);
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/ProblemScript.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/ProblemScript.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/ProblemScript.cs	(revision 11572)
@@ -0,0 +1,106 @@
+﻿#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.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 ProblemScript : Script {
+    protected bool SuppressEvents { get; set; }
+
+    [Storable]
+    private VariableStore variableStore;
+    public VariableStore VariableStore {
+      get { return variableStore; }
+    }
+
+    [StorableConstructor]
+    protected ProblemScript(bool deserializing) : base(deserializing) { }
+    protected ProblemScript(ProblemScript original, Cloner cloner)
+      : base(original, cloner) {
+      variableStore = cloner.Clone(original.variableStore);
+    }
+    protected ProblemScript() {
+      variableStore = new VariableStore();
+    }
+
+    private volatile IProblemDefinition instance;
+    private object locker = new object();
+    public IProblemDefinition Instance {
+      get {
+        SuppressEvents = true;
+        try {
+          var oldInstance = instance;
+          var compilationNecessary = false;
+          if (instance == null) {
+            lock (locker) {
+              if (instance == null) {
+                compilationNecessary = true;
+                Compile();
+              }
+            }
+          }
+          if (compilationNecessary && (oldInstance != null || instance != null))
+            OnInstanceChanged();
+          return instance;
+        } finally {
+          SuppressEvents = false;
+        }
+      }
+      protected set {
+        instance = value;
+        if (!SuppressEvents) OnInstanceChanged();
+      }
+    }
+
+    public override Assembly Compile() {
+      var assembly = base.Compile();
+      var types = assembly.GetTypes();
+      try {
+        var inst = (ProblemScriptBase)Activator.CreateInstance(types.First(x => typeof(ProblemScriptBase).IsAssignableFrom(x)));
+        inst.vars = new Variables(VariableStore);
+        inst.Initialize();
+        Instance = inst;
+      } catch {
+        Instance = null;
+      }
+      return assembly;
+    }
+
+    protected override void OnCodeChanged() {
+      base.OnCodeChanged();
+      instance = null;
+    }
+
+    public event EventHandler InstanceChanged;
+    protected virtual void OnInstanceChanged() {
+      var handler = InstanceChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/ProblemScriptBase.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/ProblemScriptBase.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/ProblemScriptBase.cs	(revision 11572)
@@ -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 System;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.Programmable {
+  public abstract class ProblemScriptBase : ProblemDefinition {
+    protected ProblemScriptBase()
+      : base(new MultiEncoding()) { }
+
+    public dynamic vars { get; set; }
+    public abstract void Initialize();
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      throw new InvalidOperationException("ProblemScript instances cannot be cloned.");
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Properties/AssemblyInfo.cs.frame	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/Properties/AssemblyInfo.cs.frame	(revision 11572)
@@ -0,0 +1,56 @@
+﻿#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.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Problems.Programmable")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002 - 2014 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("c45d2b76-5386-4f21-8d2b-ecf5c9ddaf0d")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.9.$WCREV$")]
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinition.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinition.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinition.cs	(revision 11572)
@@ -0,0 +1,42 @@
+﻿#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("Single-objective Problem Definition", "Base class for custom single-objective problem definitions.")]
+  public abstract class SingleObjectiveProblemDefinition : ProblemDefinition, ISingleObjectiveProblemDefinition {
+
+    public abstract bool IsMaximizationProblem { get; }
+    public abstract double Evaluate(IRandom random, Individual vector);
+    public virtual void Analyze(Individual[] vectors, double[] qualities, ResultCollection results) { }
+
+    [StorableConstructor]
+    protected SingleObjectiveProblemDefinition(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveProblemDefinition(SingleObjectiveProblemDefinition original, Cloner cloner) : base(original, cloner) { }
+    protected SingleObjectiveProblemDefinition(Encoding encoding) : this(encoding, "SingleObjectiveProblemDefinition", null) { }
+    protected SingleObjectiveProblemDefinition(Encoding encoding, string name) : this(encoding, name, null) { }
+    protected SingleObjectiveProblemDefinition(Encoding encoding, string name, string description) : base(encoding, name, description) { }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemScript.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemScript.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemScript.cs	(revision 11572)
@@ -0,0 +1,146 @@
+﻿#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.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 SingleObjectiveProblemScript : ProblemScript, ISingleObjectiveProblemDefinition, IStorableContent {
+    public string Filename { get; set; }
+
+    protected override string CodeTemplate {
+      get {
+        return @"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;
+
+public class CustomProblemDefinition : ProblemScriptBase, ISingleObjectiveProblemDefinition {
+  public bool IsMaximizationProblem { get { return false; } }
+
+  public CustomProblemDefinition() {
+    // Define the solution encoding which can also consist of multiple vectors, examples below
+    // Encoding = new BinaryEncoding(""b"", length: 5);
+    // Encoding = new IntegerEncoding(""i"", lenght: 5, min: 2, max: 14, step: 4);
+    // Encoding = new RealEncoding(""r"", length: 5, min: -1.0, max: 1.0);
+    // Encoding = new PermutationEncoding(""P"", length: 5, type: PermutationTypes.Absolute);
+    // Encoding = new MultiEncoding()
+      // .AddBinaryVector(""b"", length: 5)
+      // .AddIntegerVector(""i"", length: 5, min: 2, max: 14, step: 4)
+      // .AddRealVector(""r"", length: 5, min: -1.0, max: 1.0)
+      // .AddPermutation(""P"", length: 5, type: PermutationTypes.Absolute)
+    ;
+  }
+
+  public override void Initialize() {
+    // when the definition is created here you can initialize variables in the variable store
+  }
+
+  public double Evaluate(IRandom random, Individual individual) {
+    var quality = 0.0;
+    // use vars.yourVariable to access variables in the variable store i.e. yourVariable
+    // quality = individual.RealVector(""r"").Sum(x => x * x);
+    return quality;
+  }
+
+  public void Analyze(Individual[] individuals, double[] qualities, ResultCollection results) {
+    // write or update results given the range of vectors and resulting qualities
+    // use e.g. vars.yourVariable to access variables in the variable store i.e. yourVariable
+  }
+
+  public override IEnumerable<Individual> GetNeighbors(IRandom random, Individual individual) {
+    // Create new vectors, based on the given one that represent small changes
+    // This method is only called from move-based algorithms (LocalSearch, SimulatedAnnealing, etc.)
+    while (true) {
+      // this is not an infinite loop as only a finite amount of samples will be drawn
+      // it is possible to return a concrete amount of neighbors also
+      var neighbor = (Individual)individual.Clone();
+      //e.g. make a 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
+}";
+      }
+    }
+
+    [StorableConstructor]
+    private SingleObjectiveProblemScript(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveProblemScript(SingleObjectiveProblemScript original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveProblemScript() {
+      Code = CodeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveProblemScript(this, cloner);
+    }
+
+    public new ISingleObjectiveProblemDefinition Instance {
+      get { return (ISingleObjectiveProblemDefinition)base.Instance; }
+      private set { base.Instance = value; }
+    }
+
+    protected override void OnInstanceChanged() {
+      OnProblemDefinitionChanged();
+      base.OnInstanceChanged();
+    }
+
+    bool ISingleObjectiveProblemDefinition.IsMaximizationProblem {
+      get { return Instance != null && Instance.IsMaximizationProblem; }
+    }
+
+    Encoding IProblemDefinition.Encoding {
+      get { return Instance != null ? Instance.Encoding : null; }
+    }
+
+    double ISingleObjectiveProblemDefinition.Evaluate(IRandom random, Individual individual) {
+      return Instance.Evaluate(random, individual);
+    }
+
+    void ISingleObjectiveProblemDefinition.Analyze(Individual[] individuals, double[] qualities, ResultCollection results) {
+      Instance.Analyze(individuals, qualities, results);
+    }
+
+    IEnumerable<Individual> IProblemDefinition.GetNeighbors(IRandom random, Individual individual) {
+      return Instance.GetNeighbors(random, individual);
+    }
+
+    public event EventHandler ProblemDefinitionChanged;
+    private void OnProblemDefinitionChanged() {
+      var handler = ProblemDefinitionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs
===================================================================
--- /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 11572)
+++ /branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 11572)
@@ -0,0 +1,901 @@
+﻿#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.Drawing;
+using System.Linq;
+using HeuristicLab.Analysis;
+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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("Programmable Problem (single-objective)", "Represents a single-objective problem that can be programmed.")]
+  [Creatable("Problems")]
+  [StorableClass]
+  public class SingleObjectiveProgrammableProblem : SingleObjectiveHeuristicOptimizationProblem<ISingleObjectiveProgrammableProblemEvaluator, ISolutionCreator>, IParameterizedNamedItem, IStorableContent {
+    public string Filename { get; set; }
+
+    public static new Image StaticItemImage {
+      get { return Common.Resources.VSImageLibrary.Script; }
+    }
+
+    public new ParameterCollection Parameters {
+      get { return base.Parameters; }
+    }
+    IKeyedItemCollection<string, IParameter> IParameterizedItem.Parameters {
+      get { return Parameters; }
+    }
+
+    public IValueParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (IValueParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+
+    protected IValueParameter<Encoding> EncodingParameter {
+      get { return (IValueParameter<Encoding>)Parameters["Encoding"]; }
+    }
+
+    public ISingleObjectiveProblemDefinition ProblemDefinition {
+      get { return ProblemDefinitionParameter.Value; }
+      set { ProblemDefinitionParameter.Value = value; }
+    }
+
+    [Storable]
+    protected List<IParameter> DynamicEncodingParameters;
+
+    [StorableConstructor]
+    protected SingleObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
+
+    protected SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DynamicEncodingParameters = original.DynamicEncodingParameters.Select(cloner.Clone).ToList();
+      RegisterEventHandlers();
+    }
+    public SingleObjectiveProgrammableProblem()
+      : base(new SingleObjectiveEvaluator(), new MultiEncodingCreator()) {
+      Parameters.Add(new ValueParameter<ISingleObjectiveProblemDefinition>("ProblemDefinition", "Defines the problem.", new SingleObjectiveProblemScript() { Name = Name }));
+      Parameters.Add(new ValueParameter<Encoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
+
+      DynamicEncodingParameters = new List<IParameter>();
+
+      Operators.Add(new BestScopeSolutionAnalyzer());
+      Operators.Add(new SingleObjectiveAnalyzer());
+      Operators.Add(Evaluator);
+      Operators.Add(SolutionCreator);
+
+      RegisterEventHandlers();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveProgrammableProblem(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    // ReSharper disable UnusedMember.Local
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+    // ReSharper restore UnusedMember.Local
+
+    private void RegisterEventHandlers() {
+      ProblemDefinitionParameter.ValueChanged += ProblemDefinitionParameterOnValueChanged;
+      RegisterHostInstanceChanges();
+    }
+
+    private void ProblemDefinitionParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      RegisterHostInstanceChanges();
+      Parameterize();
+    }
+
+    private void RegisterHostInstanceChanges() {
+      ProblemDefinitionParameter.Value.ProblemDefinitionChanged += ProblemDefinitionChanged;
+      ProblemDefinitionParameter.Value.NameChanged += ProblemDefinitionHostOnNameChanged;
+    }
+
+    private void ProblemDefinitionHostOnNameChanged(object sender, EventArgs eventArgs) {
+      if (sender != ProblemDefinitionParameter.Value) return;
+      Name = ProblemDefinitionParameter.Value.Name;
+    }
+
+    protected override void OnNameChanged() {
+      base.OnNameChanged();
+      ProblemDefinitionParameter.Value.Name = Name;
+    }
+
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      Parameterize();
+    }
+
+    protected virtual void ProblemDefinitionChanged(object sender, EventArgs eventArgs) {
+      Parameterize();
+    }
+
+    protected virtual void Parameterize() {
+      var definition = ProblemDefinitionParameter.Value;
+      if (definition == null) return;
+
+      Encoding encoding;
+      try {
+        encoding = definition.Encoding;
+      } catch { return; }
+      EncodingParameter.Value = encoding;
+      Maximization.Value = definition.IsMaximizationProblem;
+
+      Evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
+      Evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      foreach (var evalOp in Operators.OfType<ISingleObjectiveProgrammableProblemEvaluator>()) {
+        evalOp.EncodingParameter.ActualName = EncodingParameter.Name;
+        evalOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      }
+      foreach (var analyzeOp in Operators.OfType<ISingleObjectiveProgrammableProblemAnalyzer>()) {
+        analyzeOp.EncodingParameter.ActualName = EncodingParameter.Name;
+        analyzeOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+        analyzeOp.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      }
+
+      foreach (var param in DynamicEncodingParameters)
+        if (Parameters.Contains(param)) Parameters.Remove(param);
+      DynamicEncodingParameters.Clear();
+
+      var creator = ConfigureCreator(encoding);
+
+      foreach (var param in DynamicEncodingParameters) {
+        param.Hidden = true;
+        Parameters.Add(param);
+      }
+
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        ConfigureMultiVectorEncodingOperators((MultiEncodingCreator)creator, multiEncoding);
+      } else {
+        ConfigureSingleEncodingOperators(creator, encoding);
+      }
+      UpdateImprovementOperators();
+      UpdateMoveOperators();
+    }
+
+    protected virtual ISolutionCreator ConfigureCreator(Encoding encoding) {
+      #region Configure MultiEncoding Creator
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        var creator = new MultiEncodingCreator();
+        foreach (var enc in multiEncoding.Encodings) {
+          if (enc is MultiEncoding) throw new InvalidOperationException("MultiEncoding within a MultiEncoding is not supported.");
+          creator.Operators.Add(ConfigureCreator(enc));
+        }
+        return creator;
+      }
+      #endregion
+      #region Configure BinaryVector Creator
+      var binEnc = encoding as BinaryEncoding;
+      if (binEnc != null) {
+        var p = new ValueParameter<IntValue>(binEnc.Name + "Length", binEnc.Length);
+        DynamicEncodingParameters.Add(p);
+
+        var creator = new RandomBinaryVectorCreator();
+        creator.BinaryVectorParameter.ActualName = binEnc.Name;
+        creator.LengthParameter.ActualName = p.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure IntegerVector Creator
+      var intEnc = encoding as IntegerEncoding;
+      if (intEnc != null) {
+        var l = new ValueParameter<IntValue>(intEnc.Name + "Length", intEnc.Length);
+        var b = new ValueParameter<IntMatrix>(intEnc.Name + "Bounds", intEnc.Bounds);
+        DynamicEncodingParameters.Add(l);
+        DynamicEncodingParameters.Add(b);
+
+        var creator = new UniformRandomIntegerVectorCreator();
+        creator.IntegerVectorParameter.ActualName = intEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.BoundsParameter.ActualName = b.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure RealVector Creator
+      var realEnc = encoding as RealEncoding;
+      if (realEnc != null) {
+        var l = new ValueParameter<IntValue>(realEnc.Name + "Length", realEnc.Length);
+        var b = new ValueParameter<DoubleMatrix>(realEnc.Name + "Bounds", realEnc.Bounds);
+        DynamicEncodingParameters.Add(l);
+        DynamicEncodingParameters.Add(b);
+
+        var creator = new UniformRandomRealVectorCreator();
+        creator.RealVectorParameter.ActualName = realEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.BoundsParameter.ActualName = b.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure Permutation Creator
+      var permEnc = encoding as PermutationEncoding;
+      if (permEnc != null) {
+        var l = new ValueParameter<IntValue>(permEnc.Name + "Length", permEnc.Length);
+        DynamicEncodingParameters.Add(l);
+
+        var creator = new RandomPermutationCreator();
+        creator.PermutationParameter.ActualName = permEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.PermutationTypeParameter.Value = permEnc.Type;
+        return creator;
+      }
+      #endregion
+      throw new ArgumentException(string.Format("Encoding {0} is unknown.", encoding != null ? encoding.GetType().FullName : "(null)"));
+    }
+
+    protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, Encoding encoding) {
+      // remove all multiencoding operators
+      Operators.RemoveAll(x => x is MultiEncodingCrossover
+                            || x is MultiEncodingManipulator
+                            || x is MultiEncodingCreator);
+
+      #region Configure Operators for BinaryVectorEncoding
+      var binCreator = newCreator as IBinaryVectorCreator;
+      if (binCreator != null) {
+        var paramName = binCreator.BinaryVectorParameter.ActualName;
+        // do not replace a binary vector creator that was manually set
+        if (!(SolutionCreator is IBinaryVectorCreator) || ((IBinaryVectorCreator)SolutionCreator).BinaryVectorParameter.ActualName != paramName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+
+        #region Wire BinaryVector Crossovers
+        var crossovers = Operators.OfType<IBinaryVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>(), new TypeEqualityComparer<IBinaryVectorCrossover>())
+          .ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
+          xo.ChildParameter.Hidden = true;
+          xo.ParentsParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
+          xo.ParentsParameter.Hidden = true;
+        }
+        Operators.AddRange(crossovers.Except(Operators.OfType<IBinaryVectorCrossover>()));
+        #endregion
+        #region Wire BinaryVector Manipulators
+        var manipulators = Operators.OfType<IBinaryVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>(), new TypeEqualityComparer<IBinaryVectorManipulator>())
+          .ToList();
+        foreach (var m in manipulators) {
+          m.BinaryVectorParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
+          m.BinaryVectorParameter.Hidden = true;
+        }
+        Operators.AddRange(manipulators.Except(Operators.OfType<IBinaryVectorManipulator>()));
+        #endregion
+        #region Wire BinaryVector ShakingOperators
+        var shakingOperators = Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IBinaryVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
+        foreach (var so in shakingOperators) {
+          so.BinaryVectorParameter.ActualName = paramName;
+          so.BinaryVectorParameter.Hidden = true;
+        }
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()));
+        #endregion
+      } else {
+        Operators.RemoveAll(x => x is IBinaryVectorCrossover
+          || x is IBinaryVectorManipulator
+          || x is IBinaryVectorMultiNeighborhoodShakingOperator);
+      }
+      #endregion
+      #region Configure Operators for IntegerVectorEncoding
+      var intCreator = newCreator as IIntegerVectorCreator;
+      if (intCreator != null) {
+        var paramName = intCreator.IntegerVectorParameter.ActualName;
+        // do not replace an integer vector creator that was manually set
+        if (!(SolutionCreator is IIntegerVectorCreator)
+          || ((IIntegerVectorCreator)SolutionCreator).IntegerVectorParameter.ActualName != intCreator.IntegerVectorParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+
+        #region Wire IntegerVector Crossovers
+        var crossovers = Operators.OfType<IIntegerVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>(), new TypeEqualityComparer<IIntegerVectorCrossover>())
+          .ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
+          xo.ChildParameter.Hidden = true;
+          xo.ParentsParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
+          xo.ParentsParameter.Hidden = true;
+          var bx = xo as IBoundedIntegerVectorOperator;
+          if (bx != null) {
+            bx.BoundsParameter.ActualName = intCreator.BoundsParameter.ActualName;
+            bx.BoundsParameter.Hidden = true;
+          }
+        }
+        Operators.AddRange(crossovers.Except(Operators.OfType<IIntegerVectorCrossover>()));
+        #endregion
+        #region Wire IntegerVector Manipulators
+        var manipulators = Operators.OfType<IIntegerVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>(), new TypeEqualityComparer<IIntegerVectorManipulator>())
+          .ToList();
+        foreach (var m in manipulators) {
+          m.IntegerVectorParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
+          m.IntegerVectorParameter.Hidden = true;
+          var sm = m as ISelfAdaptiveManipulator;
+          if (sm != null) {
+            var p = sm.StrategyParameterParameter as ILookupParameter;
+            if (p != null) {
+              p.ActualName = paramName + "Strategy";
+              p.Hidden = true;
+            }
+          }
+          var bm = m as IBoundedIntegerVectorOperator;
+          if (bm != null) {
+            bm.BoundsParameter.ActualName = intCreator.BoundsParameter.ActualName;
+            bm.BoundsParameter.Hidden = true;
+          }
+        }
+        Operators.AddRange(manipulators.Except(Operators.OfType<IIntegerVectorManipulator>()));
+        #region Wire IntegerVector StrategyParameters for SelfAdaptiveManipulators
+        var strategyOperators = Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IIntegerVectorStdDevStrategyParameterOperator>())
+          .ToList();
+        var problemSize = ((IntegerEncoding)encoding).Length.Value;
+        var b = ((IntegerEncoding)encoding).Bounds;
+        var bounds = new DoubleMatrix(b.Rows, b.Columns);
+        for (var i = 0; i < bounds.Rows; i++) {
+          bounds[i, 1] = (int)Math.Ceiling(0.33 * (b[i, 1] - b[i, 0]));
+          bounds[i, 0] = 0;
+          if (bounds.Columns > 2) bounds[i, 2] = b[i, 2];
+        }
+        foreach (var s in strategyOperators) {
+          var c = s as IIntegerVectorStdDevStrategyParameterCreator;
+          if (c != null) {
+            c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+            c.LengthParameter.ActualName = intCreator.LengthParameter.ActualName;
+            c.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+          var m = s as IIntegerVectorStdDevStrategyParameterManipulator;
+          if (m != null) {
+            m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+            m.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+          var mm = s as Encodings.IntegerVectorEncoding.StdDevStrategyVectorManipulator;
+          if (mm != null) {
+            mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * problemSize));
+            mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(problemSize)));
+          }
+          var x = s as IIntegerVectorStdDevStrategyParameterCrossover;
+          if (x != null) {
+            x.ParentsParameter.ActualName = paramName + "Strategy";
+            x.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+        }
+        Operators.AddRange(strategyOperators.Except(Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()));
+        #endregion
+        #endregion
+        #region Wire IntegerVector ShakingOperators
+        var shakingOperators = Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IIntegerVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
+        foreach (var so in shakingOperators) {
+          so.IntegerVectorParameter.ActualName = paramName;
+          so.IntegerVectorParameter.Hidden = true;
+        }
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()));
+        #endregion
+      } else {
+        Operators.RemoveAll(x => x is IIntegerVectorCrossover
+          || x is IIntegerVectorManipulator
+          || x is IIntegerVectorStdDevStrategyParameterOperator
+          || x is IIntegerVectorMultiNeighborhoodShakingOperator);
+      }
+      #endregion
+      #region Configure Operators for RealVectorEncoding
+      var realCreator = newCreator as IRealVectorCreator;
+      if (realCreator != null) {
+        var paramName = realCreator.RealVectorParameter.ActualName;
+        // do not replace a real vector creator that was manually set
+        if (!(SolutionCreator is IRealVectorCreator)
+            || ((IRealVectorCreator)SolutionCreator).RealVectorParameter.ActualName != realCreator.RealVectorParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+
+        #region Wire RealVector Crossovers
+        var crossovers = Operators.OfType<IRealVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorCrossover>(), new TypeEqualityComparer<IRealVectorCrossover>())
+          .ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = paramName;
+          xo.ChildParameter.Hidden = true;
+          xo.ParentsParameter.ActualName = paramName;
+          xo.ParentsParameter.Hidden = true;
+          xo.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+          xo.BoundsParameter.Hidden = true;
+        }
+        Operators.AddRange(crossovers.Except(Operators.OfType<IRealVectorCrossover>()));
+        #endregion
+        #region Wire RealVector Manipulators
+        var manipulators = Operators.OfType<IRealVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorManipulator>(), new TypeEqualityComparer<IRealVectorManipulator>())
+          .ToList();
+        foreach (var m in manipulators) {
+          m.RealVectorParameter.ActualName = paramName;
+          m.RealVectorParameter.Hidden = true;
+          m.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+          m.BoundsParameter.Hidden = true;
+          var sm = m as ISelfAdaptiveManipulator;
+          if (sm != null) {
+            var p = sm.StrategyParameterParameter as ILookupParameter;
+            if (p != null) {
+              p.ActualName = paramName + "Strategy";
+              p.Hidden = true;
+            }
+          }
+        }
+        Operators.AddRange(manipulators.Except(Operators.OfType<IRealVectorManipulator>()));
+        #region Wire RealVector Strategy Parameters for SelfAdaptiveManipulators
+        var strategyOperators = Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IRealVectorStdDevStrategyParameterOperator>())
+          .ToList();
+        var problemSize = ((RealEncoding)encoding).Length.Value;
+        var bounds = (DoubleMatrix)((RealEncoding)encoding).Bounds.Clone();
+        for (var i = 0; i < bounds.Rows; i++) {
+          bounds[i, 1] = 0.1 * (bounds[i, 1] - bounds[i, 0]);
+          bounds[i, 0] = 0;
+        }
+        foreach (var s in strategyOperators) {
+          var c = s as IRealVectorStdDevStrategyParameterCreator;
+          if (c != null) {
+            c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+            c.LengthParameter.ActualName = realCreator.LengthParameter.ActualName;
+            c.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+          var m = s as IRealVectorStdDevStrategyParameterManipulator;
+          if (m != null) {
+            m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+            m.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+          var mm = s as Encodings.RealVectorEncoding.StdDevStrategyVectorManipulator;
+          if (mm != null) {
+            mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * problemSize));
+            mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(problemSize)));
+          }
+          var x = s as IRealVectorStdDevStrategyParameterCrossover;
+          if (x != null) {
+            x.ParentsParameter.ActualName = paramName + "Strategy";
+            x.StrategyParameterParameter.ActualName = paramName + "Strategy";
+          }
+        }
+        Operators.AddRange(strategyOperators.Except(Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()));
+        #endregion
+        #endregion
+        #region Wire RealVector ParticleCreators
+        var particleCreators = Operators.OfType<IRealVectorParticleCreator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleCreator>(), new TypeEqualityComparer<IRealVectorParticleCreator>())
+          .ToList();
+        foreach (var pc in particleCreators) {
+          pc.RealVectorParameter.ActualName = paramName;
+          pc.RealVectorParameter.Hidden = true;
+          pc.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+          pc.BoundsParameter.Hidden = true;
+          pc.ProblemSizeParameter.ActualName = realCreator.LengthParameter.ActualName;
+          pc.ProblemSizeParameter.Hidden = true;
+        }
+        Operators.AddRange(particleCreators.Except(Operators.OfType<IRealVectorParticleCreator>()));
+        #endregion
+        #region Wire RealVector ParticleUpdaters
+        var particleUpdaters = Operators.OfType<IRealVectorParticleUpdater>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleUpdater>(), new TypeEqualityComparer<IRealVectorParticleUpdater>())
+          .ToList();
+        foreach (var pu in particleUpdaters) {
+          pu.RealVectorParameter.ActualName = paramName;
+          pu.RealVectorParameter.Hidden = true;
+          pu.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+          pu.BoundsParameter.Hidden = true;
+        }
+        Operators.AddRange(particleUpdaters.Except(Operators.OfType<IRealVectorParticleUpdater>()));
+        #endregion
+        #region Wire RealVector SwarmUpdaters
+        var swarmUpdaters = Operators.OfType<IRealVectorSwarmUpdater>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorSwarmUpdater>(), new TypeEqualityComparer<IRealVectorSwarmUpdater>())
+          .ToList();
+        foreach (var su in swarmUpdaters) {
+          su.RealVectorParameter.ActualName = paramName;
+          su.RealVectorParameter.Hidden = true;
+          su.MaximizationParameter.ActualName = MaximizationParameter.Name;
+          su.MaximizationParameter.Hidden = true;
+        }
+        Operators.AddRange(swarmUpdaters.Except(Operators.OfType<IRealVectorSwarmUpdater>()));
+        #endregion
+        #region Wire RealVector ShakingOperators
+        var shakingOperators = Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IRealVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
+        foreach (var so in shakingOperators) {
+          so.RealVectorParameter.ActualName = paramName;
+          so.RealVectorParameter.Hidden = true;
+        }
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()));
+        #endregion
+      } else {
+        Operators.RemoveAll(x => x is IRealVectorCrossover
+          || x is IRealVectorManipulator
+          || x is IRealVectorStdDevStrategyParameterOperator
+          || x is IRealVectorParticleCreator
+          || x is IRealVectorParticleUpdater
+          || x is IRealVectorSwarmUpdater
+          || x is IRealVectorMultiNeighborhoodShakingOperator);
+      }
+      #endregion
+      #region Configure Operators for PermutationEncoding
+      var permCreator = newCreator as IPermutationCreator;
+      if (permCreator != null) {
+        var paramName = permCreator.PermutationParameter.ActualName;
+        // do not replace a permutation creator that was manually set
+        if (!(SolutionCreator is IPermutationCreator)
+            || ((IPermutationCreator)SolutionCreator).PermutationParameter.ActualName != permCreator.PermutationParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+
+        #region Wire Permutation Crossovers
+        var crossovers = Operators.OfType<IPermutationCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationCrossover>(), new TypeEqualityComparer<IPermutationCrossover>())
+          .ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = permCreator.PermutationParameter.ActualName;
+          xo.ChildParameter.Hidden = true;
+          xo.ParentsParameter.ActualName = permCreator.PermutationParameter.ActualName;
+          xo.ParentsParameter.Hidden = true;
+        }
+        Operators.AddRange(crossovers.Except(Operators.OfType<IPermutationCrossover>()));
+        #endregion
+        #region Wire Permutation Manipulators
+        var manipulators = Operators.OfType<IPermutationManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationManipulator>(), new TypeEqualityComparer<IPermutationManipulator>())
+          .ToList();
+        foreach (var m in manipulators) {
+          m.PermutationParameter.ActualName = permCreator.PermutationParameter.ActualName;
+          m.PermutationParameter.Hidden = true;
+        }
+        Operators.AddRange(manipulators.Except(Operators.OfType<IPermutationManipulator>()));
+        #endregion
+        #region Wire Permutation ShakingOperators
+        var shakingOperators = Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IPermutationMultiNeighborhoodShakingOperator>())
+          .ToList();
+        foreach (var op in shakingOperators) {
+          op.PermutationParameter.ActualName = paramName;
+          op.PermutationParameter.Hidden = true;
+        }
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()));
+        #endregion
+      } else {
+        Operators.RemoveAll(x => x is IPermutationCrossover
+          || x is IPermutationManipulator
+          || x is IPermutationMultiNeighborhoodShakingOperator);
+      }
+      #endregion
+    }
+
+    protected virtual void ConfigureMultiVectorEncodingOperators(MultiEncodingCreator newCreator, MultiEncoding encoding) {
+      var newBinParams = new HashSet<string>(newCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
+      var newIntParams = new HashSet<string>(newCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
+      var newRealParams = new HashSet<string>(newCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
+      var newPermParams = new HashSet<string>(newCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
+
+      var oldCreator = SolutionCreator as MultiEncodingCreator;
+      if (oldCreator == null) SolutionCreator = newCreator;
+      else {
+        #region Configure BinaryVector Creator
+        var oldBinParams = new HashSet<string>(oldCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
+        foreach (var toAdd in newBinParams.Except(oldBinParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IBinaryVectorCreator>().Single(x => x.BinaryVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+          var op = oldCreator.Operators.OfType<IBinaryVectorCreator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+        #endregion
+
+        #region Configure IntegerVector Creator
+        var oldIntParams = new HashSet<string>(oldCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
+        foreach (var toAdd in newIntParams.Except(oldIntParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IIntegerVectorCreator>().Single(x => x.IntegerVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+          var op = oldCreator.Operators.OfType<IIntegerVectorCreator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+        #endregion
+
+        #region Configure RealVector Creator
+        var oldRealParams = new HashSet<string>(oldCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
+        foreach (var toAdd in newRealParams.Except(oldRealParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IRealVectorCreator>().Single(x => x.RealVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+          var op = oldCreator.Operators.OfType<IRealVectorCreator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+        #endregion
+
+        #region Configure Permutation Creator
+        var oldPermParams = new HashSet<string>(oldCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
+        foreach (var toAdd in newPermParams.Except(oldPermParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+          var op = oldCreator.Operators.OfType<IPermutationCreator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+        // we also have to sync the permutation type (in case this changes, as it is a value parameter)
+        foreach (var intersect in newPermParams.Intersect(oldPermParams)) {
+          var oldPermCreator = oldCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
+          var newPermCreator = newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
+          oldPermCreator.PermutationTypeParameter.Value = newPermCreator.PermutationTypeParameter.Value;
+        }
+        #endregion
+
+      }
+
+      // crossover and manipulator for multi-vector encoding
+      // the condition checks if a multi-vector encoding is to be updated (there already exists ParameterVectorCrossover and ParameterVectorManipulator)
+      if (Operators.OfType<MultiEncodingCrossover>().Any() && Operators.OfType<MultiEncodingManipulator>().Any()) {
+        #region Update existing multi-vector encoding
+        #region Update ParameterVector Crossover ...
+        foreach (var oldXo in Operators.OfType<MultiEncodingCrossover>()) {
+          #region ... for binary parameters
+          var oldBinParams = new HashSet<string>(oldXo.Operators.OfType<IBinaryVectorCrossover>().Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newBinParams.Except(oldBinParams))
+            oldXo.Operators.Add(GetDefaultBinaryCrossover(toAdd, encoding));
+          foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op = oldXo.Operators.OfType<IBinaryVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for integer parameters
+          var oldIntParams = new HashSet<string>(oldXo.Operators.OfType<IIntegerVectorCrossover>().Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newIntParams.Except(oldIntParams))
+            oldXo.Operators.Add(GetDefaultIntegerCrossover(toAdd, encoding));
+          foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op = oldXo.Operators.OfType<IIntegerVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for real parameters
+          var oldRealParams = new HashSet<string>(oldXo.Operators.OfType<IRealVectorCrossover>().Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newRealParams.Except(oldRealParams))
+            oldXo.Operators.Add(GetDefaultRealCrossover(toAdd, encoding));
+          foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op = oldXo.Operators.OfType<IRealVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for permutation parameters
+          var oldPermParams = new HashSet<string>(oldXo.Operators.OfType<IPermutationCrossover>().Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newPermParams.Except(oldPermParams))
+            oldXo.Operators.Add(GetDefaultPermutationCrossover(toAdd, encoding));
+          foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op = oldXo.Operators.OfType<IPermutationCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+          #endregion
+        }
+        #endregion
+        #region Update ParameterVector Manipulator ...
+        foreach (var oldM in Operators.OfType<MultiEncodingManipulator>()) {
+          #region ... for binary parameters
+          var oldBinParams = new HashSet<string>(oldM.Operators.OfType<IBinaryVectorManipulator>().Select(x => x.BinaryVectorParameter.ActualName));
+          foreach (var toAdd in newBinParams.Except(oldBinParams))
+            oldM.Operators.Add(GetDefaultBinaryManipulator(toAdd, encoding));
+          foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op = oldM.Operators.OfType<IBinaryVectorManipulator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for integer parameters
+          var oldIntParams = new HashSet<string>(oldM.Operators.OfType<IIntegerVectorManipulator>().Select(x => x.IntegerVectorParameter.ActualName));
+          foreach (var toAdd in newIntParams.Except(oldIntParams))
+            oldM.Operators.Add(GetDefaultIntegerManipulator(toAdd, encoding));
+          foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op = oldM.Operators.OfType<IIntegerVectorManipulator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for real parameters
+          var oldRealParams = new HashSet<string>(oldM.Operators.OfType<IRealVectorManipulator>().Select(x => x.RealVectorParameter.ActualName));
+          foreach (var toAdd in newRealParams.Except(oldRealParams))
+            oldM.Operators.Add(GetDefaultRealManipulator(toAdd, encoding));
+          foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op = oldM.Operators.OfType<IRealVectorManipulator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+          #endregion
+          #region ... for permutation parameters
+          var oldPermParams = new HashSet<string>(oldM.Operators.OfType<IPermutationManipulator>().Select(x => x.PermutationParameter.ActualName));
+          foreach (var toAdd in newPermParams.Except(oldPermParams))
+            oldM.Operators.Add(GetDefaultPermutationManipulator(toAdd, encoding));
+          foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op = oldM.Operators.OfType<IPermutationManipulator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+          #endregion
+        }
+        #endregion
+        #endregion
+      } else {
+        #region Handle transition from single-vector to multi-vector encoding
+        Operators.RemoveAll(x => x is ICrossover);
+        Operators.RemoveAll(x => x is IManipulator);
+        Operators.RemoveAll(x => x is IStrategyParameterCreator || x is IStrategyParameterManipulator || x is IStrategyParameterCrossover);
+        Operators.RemoveAll(x => x is IParticleCreator);
+        Operators.RemoveAll(x => x is IParticleUpdater);
+        Operators.RemoveAll(x => x is ISwarmUpdater);
+        Operators.RemoveAll(x => x is IMultiNeighborhoodShakingOperator);
+
+        var crossover = new MultiEncodingCrossover();
+        var manipulator = new MultiEncodingManipulator();
+        foreach (var enc in encoding.Encodings) {
+          if (enc is BinaryEncoding) {
+            crossover.Operators.Add(GetDefaultBinaryCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultBinaryManipulator(enc.Name, encoding));
+            continue;
+          }
+          var intConfig = enc as IntegerEncoding;
+          if (intConfig != null) {
+            crossover.Operators.Add(GetDefaultIntegerCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultIntegerManipulator(enc.Name, encoding));
+            continue;
+          }
+          var realConfig = enc as RealEncoding;
+          if (realConfig != null) {
+            crossover.Operators.Add(GetDefaultRealCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultRealManipulator(enc.Name, encoding));
+            continue;
+          }
+          var permConfig = enc as PermutationEncoding;
+          if (permConfig != null) {
+            crossover.Operators.Add(GetDefaultPermutationCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultPermutationManipulator(enc.Name, encoding));
+            continue;
+          }
+          throw new InvalidOperationException("Unknown type for parameter " + enc.Name);
+        }
+        Operators.Add(crossover);
+        Operators.Add(manipulator);
+        #endregion
+      }
+    }
+
+    protected virtual void UpdateImprovementOperators() {
+      if (!Operators.Any(x => x is SingleObjectiveImprover))
+        Operators.Add(new SingleObjectiveImprover());
+      foreach (var improver in Operators.OfType<SingleObjectiveImprover>()) {
+        improver.EncodingParameter.ActualName = EncodingParameter.Name;
+        improver.MaximizationParameter.ActualName = MaximizationParameter.Name;
+        improver.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+        improver.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      }
+    }
+
+    protected virtual void UpdateMoveOperators() {
+      if (!Operators.Any(x => x is SingleObjectiveMoveGenerator))
+        Operators.Add(new SingleObjectiveMoveGenerator());
+      if (!Operators.Any(x => x is SingleObjectiveMoveEvaluator))
+        Operators.Add(new SingleObjectiveMoveEvaluator());
+      if (!Operators.Any(x => x is SingleObjectiveMoveMaker))
+        Operators.Add(new SingleObjectiveMoveMaker());
+
+      foreach (var generator in Operators.OfType<SingleObjectiveMoveGenerator>()) {
+        generator.EncodingParameter.ActualName = EncodingParameter.Name;
+        generator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      }
+      foreach (var evaluator in Operators.OfType<SingleObjectiveMoveEvaluator>()) {
+        evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
+        evaluator.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+        evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      }
+      foreach (var maker in Operators.OfType<SingleObjectiveMoveMaker>()) {
+        maker.EncodingParameter.ActualName = EncodingParameter.Name;
+        maker.MoveQualityParameter.ActualName = Operators.OfType<SingleObjectiveMoveEvaluator>().First().MoveQualityParameter.ActualName;
+        maker.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      }
+    }
+
+    #region GetDefaultOperators for Crossovers and Manipulators
+    // ReSharper disable RedundantNameQualifier
+    protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, MultiEncoding config) {
+      var binConfig = (BinaryEncoding)config.Encodings[paramName];
+      IBinaryVectorCrossover binXo;
+      if (binConfig.Length.Value > 3) binXo = new Encodings.BinaryVectorEncoding.SinglePointCrossover();
+      else binXo = new Encodings.BinaryVectorEncoding.UniformCrossover();
+      binXo.ChildParameter.ActualName = paramName;
+      binXo.ParentsParameter.ActualName = paramName;
+      return binXo;
+    }
+
+    protected virtual IBinaryVectorManipulator GetDefaultBinaryManipulator(string paramName, MultiEncoding config) {
+      var binM = new Encodings.BinaryVectorEncoding.SomePositionsBitflipManipulator();
+      binM.BinaryVectorParameter.ActualName = paramName;
+      binM.MutationProbabilityParameter.Value = new DoubleValue(0.1);
+      return binM;
+    }
+
+    protected virtual IIntegerVectorCrossover GetDefaultIntegerCrossover(string paramName, MultiEncoding config) {
+      var intXo = new Encodings.IntegerVectorEncoding.RoundedBlendAlphaBetaCrossover();
+      intXo.ChildParameter.ActualName = paramName;
+      intXo.ParentsParameter.ActualName = paramName;
+      intXo.BoundsParameter.ActualName = paramName + "Bounds";
+      intXo.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      intXo.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      return intXo;
+    }
+
+    protected virtual IIntegerVectorManipulator GetDefaultIntegerManipulator(string paramName, MultiEncoding configuration) {
+      var intM = new Encodings.IntegerVectorEncoding.UniformSomePositionsManipulator();
+      intM.IntegerVectorParameter.ActualName = paramName;
+      intM.BoundsParameter.ActualName = paramName + "Bounds";
+      intM.ProbabilityParameter.Value = new DoubleValue(0.1);
+      return intM;
+    }
+
+    protected virtual IRealVectorCrossover GetDefaultRealCrossover(string paramName, MultiEncoding configuration) {
+      var realXo = new Encodings.RealVectorEncoding.BlendAlphaBetaCrossover();
+      realXo.ChildParameter.ActualName = paramName;
+      realXo.ParentsParameter.ActualName = paramName;
+      realXo.BoundsParameter.ActualName = paramName + "Bounds";
+      realXo.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      realXo.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      return realXo;
+    }
+
+    protected virtual IRealVectorManipulator GetDefaultRealManipulator(string paramName, MultiEncoding configuration) {
+      var realM = new Encodings.RealVectorEncoding.BreederGeneticAlgorithmManipulator();
+      realM.RealVectorParameter.ActualName = paramName;
+      realM.BoundsParameter.ActualName = paramName + "Bounds";
+      return realM;
+    }
+
+    protected virtual IPermutationCrossover GetDefaultPermutationCrossover(string paramName, MultiEncoding configuration) {
+      var permXo = new Encodings.PermutationEncoding.PartiallyMatchedCrossover();
+      permXo.ChildParameter.ActualName = paramName;
+      permXo.ParentsParameter.ActualName = paramName;
+      return permXo;
+    }
+
+    protected virtual IPermutationManipulator GetDefaultPermutationManipulator(string paramName, MultiEncoding configuration) {
+      var permM = new Encodings.PermutationEncoding.Swap2Manipulator();
+      permM.PermutationParameter.ActualName = paramName;
+      return permM;
+    }
+    // ReSharper restore RedundantNameQualifier
+    #endregion
+  }
+}
