Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/AlgorithmBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/AlgorithmBase.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/AlgorithmBase.cs	(revision 2341)
@@ -0,0 +1,503 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Xml;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Evolutionary;
+using HeuristicLab.Logging;
+using HeuristicLab.Operators;
+using HeuristicLab.Random;
+using HeuristicLab.Selection;
+using HeuristicLab.GP.Operators;
+
+namespace HeuristicLab.GP.Algorithms {
+  public abstract class AlgorithmBase : ItemBase {
+    public virtual string Name { get { return "GP"; } }
+    public virtual string Description { get { return "TODO"; } }
+
+    public virtual double MutationRate {
+      get { return GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data = value; }
+    }
+    public virtual int PopulationSize {
+      get { return GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual int MaxGenerations {
+      get { return GetVariableInjector().GetVariable("MaxGenerations").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxGenerations").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual int Elites {
+      get { return GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual int MaxTreeSize {
+      get { return GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual int MinTreeSize {
+      get { return GetVariableInjector().GetVariable("MinTreeSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MinTreeSize").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual int MaxTreeHeight {
+      get { return GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual int Parents {
+      get { return GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual bool SetSeedRandomly {
+      get { return GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data; }
+      set { GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data = value; }
+    }
+
+    public virtual int RandomSeed {
+      get { return GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data; }
+      set { GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual IOperator ProblemInjector {
+      get { return GetInitializationOperator().SubOperators[0]; }
+      set {
+        value.Name = "ProblemInjector";
+        IOperator init = GetInitializationOperator();
+        init.RemoveSubOperator(0);
+        init.AddSubOperator(value, 0);
+      }
+    }
+
+    public virtual IOperator FunctionLibraryInjector {
+      get { return GetInitializationOperator().SubOperators[1]; }
+      set {
+        value.Name = "FunctionLibraryInjector";
+        IOperator init = GetInitializationOperator();
+        init.RemoveSubOperator(1);
+        init.AddSubOperator(value, 1);
+      }
+    }
+
+    private IOperator algorithm;
+
+    private SequentialEngine.SequentialEngine engine;
+    public IEngine Engine {
+      get { return engine; }
+      protected set { engine = (SequentialEngine.SequentialEngine)value; }
+    }
+
+    public AlgorithmBase() {
+      engine = new SequentialEngine.SequentialEngine();
+      CombinedOperator algo = CreateAlgorithm();
+      engine.OperatorGraph.AddOperator(algo);
+      engine.OperatorGraph.InitialOperator = algo;
+      SetSeedRandomly = true;
+      Elites = 1;
+      MutationRate = 0.15;
+      PopulationSize = 1000;
+      MaxGenerations = 100;
+      MaxTreeSize = 100;
+      MinTreeSize = 1;
+      MaxTreeHeight = 10;
+      Parents = 2000;
+    }
+
+    protected internal virtual CombinedOperator CreateAlgorithm() {
+      CombinedOperator algo = new CombinedOperator();
+      algo.Name = "GP";
+      SequentialProcessor seq = new SequentialProcessor();
+      IOperator init = CreateInitializationOperator();
+      init.AddSubOperator(CreateProblemInjector());
+      init.AddSubOperator(CreateFunctionLibraryInjector());
+      seq.AddSubOperator(init);
+
+      IOperator initPopulation = CreateInitialPopulationGenerator();
+      initPopulation.AddSubOperator(CreateRandomSolutionGenerator());
+      initPopulation.AddSubOperator(CreateInitialPopulationEvaluator());
+      seq.AddSubOperator(initPopulation);
+
+      IOperator mainLoop = CreateMainLoop();
+      mainLoop.AddSubOperator(CreateSelectionOperator());
+      mainLoop.AddSubOperator(CreateCrossoverOperator());
+      mainLoop.AddSubOperator(CreateManipulationOperator());
+      mainLoop.AddSubOperator(CreateEvaluationOperator());
+      mainLoop.AddSubOperator(CreateTerminationCondition());
+      seq.AddSubOperator(mainLoop);
+
+      IOperator postProcess = CreatePostProcessingOperator();
+      seq.AddSubOperator(postProcess);
+
+      algo.OperatorGraph.AddOperator(seq);
+      algo.OperatorGraph.InitialOperator = seq;
+      this.algorithm = seq;
+      return algo;
+    }
+
+    #region global init
+    protected virtual IOperator CreateInitializationOperator() {
+      CombinedOperator init = new CombinedOperator();
+      init.Name = "Initialization";
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(CreateRandomInjector());
+      seq.AddSubOperator(CreateGlobalInjector());
+
+      OperatorExtractor probInjectorExtractor = new OperatorExtractor();
+      probInjectorExtractor.Name = "ProblemInjector";
+      probInjectorExtractor.GetVariableInfo("Operator").ActualName = "ProblemInjector";
+      seq.AddSubOperator(probInjectorExtractor);
+
+      OperatorExtractor funLibInjectorExtractor = new OperatorExtractor();
+      funLibInjectorExtractor.Name = "FunctionLibraryInjector";
+      funLibInjectorExtractor.GetVariableInfo("Operator").ActualName = "FunctionLibraryInjector";
+      seq.AddSubOperator(funLibInjectorExtractor);
+
+      init.OperatorGraph.AddOperator(seq);
+      init.OperatorGraph.InitialOperator = seq;
+      return init;
+    }
+
+    protected virtual IOperator CreateRandomInjector() {
+      RandomInjector randomInjector = new RandomInjector();
+      randomInjector.Name = "Random Injector";
+      return randomInjector;
+    }
+
+    protected virtual VariableInjector CreateGlobalInjector() {
+      VariableInjector injector = new VariableInjector();
+      injector.Name = "Global Injector";
+      injector.AddVariable(new HeuristicLab.Core.Variable("Generations", new IntData(0)));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxGenerations", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", new DoubleData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("Maximization", new BoolData(false)));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MinTreeSize", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("EvaluatedSolutions", new IntData(0)));
+      injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
+      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", new IntData()));
+      return injector;
+    }
+
+
+    protected virtual IOperator CreateProblemInjector() {
+      return new EmptyOperator();
+    }
+
+    protected virtual IOperator CreateFunctionLibraryInjector() {
+      return new EmptyOperator();
+    }
+    #endregion
+
+    #region population init
+    private IOperator CreateInitialPopulationGenerator() {
+      CombinedOperator initPopulation = new CombinedOperator();
+      initPopulation.Name = "Init population";
+      SequentialProcessor seq = new SequentialProcessor();
+      SubScopesCreater subScopesCreater = new SubScopesCreater();
+      subScopesCreater.GetVariableInfo("SubScopes").ActualName = "PopulationSize";
+      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
+      SequentialProcessor individualSeq = new SequentialProcessor();
+      OperatorExtractor treeCreater = new OperatorExtractor();
+      treeCreater.Name = "Tree generator (extr.)";
+      treeCreater.GetVariableInfo("Operator").ActualName = "Solution generator";
+
+      OperatorExtractor evaluator = new OperatorExtractor();
+      evaluator.Name = "Evaluator (extr.)";
+      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
+      Counter evalCounter = new Counter();
+      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
+      Sorter sorter = new Sorter();
+      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
+      sorter.GetVariableInfo("Value").ActualName = "Quality";
+
+      seq.AddSubOperator(subScopesCreater);
+      seq.AddSubOperator(subScopesProc);
+      seq.AddSubOperator(sorter);
+
+      subScopesProc.AddSubOperator(individualSeq);
+      individualSeq.AddSubOperator(treeCreater);
+      individualSeq.AddSubOperator(evaluator);
+      individualSeq.AddSubOperator(evalCounter);
+
+      initPopulation.OperatorGraph.AddOperator(seq);
+      initPopulation.OperatorGraph.InitialOperator = seq;
+      return initPopulation;
+    }
+
+    protected virtual IOperator CreateRandomSolutionGenerator() {
+      ProbabilisticTreeCreator treeCreator = new ProbabilisticTreeCreator();
+      treeCreator.Name = "Solution generator";
+      return treeCreator;
+    }
+
+    protected virtual IOperator CreateInitialPopulationEvaluator() {
+      return new EmptyOperator();
+    }
+    #endregion
+
+    #region mainloop
+    protected virtual IOperator CreateMainLoop() {
+      CombinedOperator main = new CombinedOperator();
+      main.Name = "Main";
+      SequentialProcessor seq = new SequentialProcessor();
+      IOperator childCreater = CreateChildCreater();
+      IOperator replacement = CreateReplacement();
+
+      BestAverageWorstQualityCalculator qualityCalculator = new BestAverageWorstQualityCalculator();
+      IOperator loggingOperator = CreateLoggingOperator();
+      Counter counter = new Counter();
+      counter.GetVariableInfo("Value").ActualName = "Generations";
+
+      OperatorExtractor terminationCriterionExtractor = new OperatorExtractor();
+      terminationCriterionExtractor.Name = "TerminationCondition (extr.)";
+      terminationCriterionExtractor.GetVariableInfo("Operator").ActualName = "TerminationCondition";
+
+      ConditionalBranch loop = new ConditionalBranch();
+      loop.Name = "Main loop";
+      loop.GetVariableInfo("Condition").ActualName = "TerminationCriterion";
+      loop.AddSubOperator(new EmptyOperator());
+      loop.AddSubOperator(seq);
+
+      seq.AddSubOperator(childCreater);
+      seq.AddSubOperator(replacement);
+      seq.AddSubOperator(qualityCalculator);
+      seq.AddSubOperator(CreateGenerationStepHook());
+      seq.AddSubOperator(loggingOperator);
+      seq.AddSubOperator(counter);
+      seq.AddSubOperator(terminationCriterionExtractor);
+      seq.AddSubOperator(loop);
+
+      main.OperatorGraph.AddOperator(seq);
+      main.OperatorGraph.InitialOperator = seq;
+      return main;
+    }
+
+    protected virtual IOperator CreateChildCreater() {
+      CombinedOperator childCreater = new CombinedOperator();
+      childCreater.Name = "Create children";
+      SequentialProcessor seq = new SequentialProcessor();
+      OperatorExtractor selector = new OperatorExtractor();
+      selector.Name = "Selector (extr.)";
+      selector.GetVariableInfo("Operator").ActualName = "Selector";
+
+      SequentialSubScopesProcessor seqScopesProc = new SequentialSubScopesProcessor();
+      EmptyOperator emptyOpt = new EmptyOperator();
+      SequentialProcessor selectedProc = new SequentialProcessor();
+      ChildrenInitializer childInitializer = new ChildrenInitializer();
+      ((IntData)childInitializer.GetVariable("ParentsPerChild").Value).Data = 2;
+
+      OperatorExtractor crossover = new OperatorExtractor();
+      crossover.Name = "Crossover (extr.)";
+      crossover.GetVariableInfo("Operator").ActualName = "Crossover";
+      UniformSequentialSubScopesProcessor individualProc = new UniformSequentialSubScopesProcessor();
+      SequentialProcessor individualSeqProc = new SequentialProcessor();
+      StochasticBranch cond = new StochasticBranch();
+      cond.GetVariableInfo("Probability").ActualName = "MutationRate";
+      OperatorExtractor manipulator = new OperatorExtractor();
+      manipulator.Name = "Manipulator (extr.)";
+      manipulator.GetVariableInfo("Operator").ActualName = "Manipulator";
+      OperatorExtractor evaluator = new OperatorExtractor();
+      evaluator.Name = "Evaluator (extr.)";
+      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
+      Counter evalCounter = new Counter();
+      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
+      SubScopesRemover parentRefRemover = new SubScopesRemover();
+
+      Sorter sorter = new Sorter();
+      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
+      sorter.GetVariableInfo("Value").ActualName = "Quality";
+
+
+      seq.AddSubOperator(selector);
+      seq.AddSubOperator(seqScopesProc);
+      seqScopesProc.AddSubOperator(emptyOpt);
+      seqScopesProc.AddSubOperator(selectedProc);
+      selectedProc.AddSubOperator(childInitializer);
+      selectedProc.AddSubOperator(individualProc);
+      individualProc.AddSubOperator(individualSeqProc);
+      individualSeqProc.AddSubOperator(crossover);
+      individualSeqProc.AddSubOperator(cond);
+      cond.AddSubOperator(manipulator);
+      individualSeqProc.AddSubOperator(evaluator);
+      individualSeqProc.AddSubOperator(evalCounter);
+      individualSeqProc.AddSubOperator(parentRefRemover);
+      selectedProc.AddSubOperator(sorter);
+
+      childCreater.OperatorGraph.AddOperator(seq);
+      childCreater.OperatorGraph.InitialOperator = seq;
+      return childCreater;
+    }
+
+    protected virtual IOperator CreateReplacement() {
+      CombinedOperator replacement = new CombinedOperator();
+      replacement.Name = "Replacement";
+      SequentialProcessor seq = new SequentialProcessor();
+      SequentialSubScopesProcessor seqScopeProc = new SequentialSubScopesProcessor();
+      SequentialProcessor selectedProc = new SequentialProcessor();
+      LeftSelector leftSelector = new LeftSelector();
+      leftSelector.GetVariableInfo("Selected").ActualName = "Elites";
+      RightReducer rightReducer = new RightReducer();
+
+      SequentialProcessor remainingProc = new SequentialProcessor();
+      RightSelector rightSelector = new RightSelector();
+      rightSelector.GetVariableInfo("Selected").ActualName = "Elites";
+      LeftReducer leftReducer = new LeftReducer();
+      MergingReducer mergingReducer = new MergingReducer();
+      Sorter sorter = new Sorter();
+      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
+      sorter.GetVariableInfo("Value").ActualName = "Quality";
+
+      seq.AddSubOperator(seqScopeProc);
+      seqScopeProc.AddSubOperator(selectedProc);
+      selectedProc.AddSubOperator(leftSelector);
+      selectedProc.AddSubOperator(rightReducer);
+
+      seqScopeProc.AddSubOperator(remainingProc);
+      remainingProc.AddSubOperator(rightSelector);
+      remainingProc.AddSubOperator(leftReducer);
+      seq.AddSubOperator(mergingReducer);
+      seq.AddSubOperator(sorter);
+      replacement.OperatorGraph.AddOperator(seq);
+      replacement.OperatorGraph.InitialOperator = seq;
+      return replacement;
+    }
+
+    protected virtual IOperator CreateLoggingOperator() {
+      CombinedOperator loggingOperator = new CombinedOperator();
+      loggingOperator.Name = "Logging";
+      SequentialProcessor seq = new SequentialProcessor();
+
+      DataCollector collector = new DataCollector();
+      ItemList<StringData> names = collector.GetVariable("VariableNames").GetValue<ItemList<StringData>>();
+      names.Add(new StringData("BestQuality"));
+      names.Add(new StringData("AverageQuality"));
+      names.Add(new StringData("WorstQuality"));
+      LinechartInjector lineChartInjector = new LinechartInjector();
+      lineChartInjector.GetVariableInfo("Linechart").ActualName = "Quality Linechart";
+      lineChartInjector.GetVariable("NumberOfLines").GetValue<IntData>().Data = 3;
+      QualityLogger qualityLogger = new QualityLogger();
+
+      seq.AddSubOperator(collector);
+      seq.AddSubOperator(lineChartInjector);
+      seq.AddSubOperator(qualityLogger);
+
+      loggingOperator.OperatorGraph.AddOperator(seq);
+      loggingOperator.OperatorGraph.InitialOperator = seq;
+      return loggingOperator;
+    }
+
+    protected virtual IOperator CreateGenerationStepHook() {
+      return new EmptyOperator();
+    }
+
+    protected virtual IOperator CreateTerminationCondition() {
+      CombinedOperator terminationCriterion = new CombinedOperator();
+      terminationCriterion.Name = "TerminationCondition";
+      SequentialProcessor seq = new SequentialProcessor();
+      GreaterThanComparator comparator = new GreaterThanComparator();
+      comparator.GetVariableInfo("LeftSide").ActualName = "Generations";
+      comparator.GetVariableInfo("RightSide").ActualName = "MaxGenerations";
+      comparator.GetVariableInfo("Result").ActualName = "TerminationCriterion";
+
+      seq.AddSubOperator(comparator);
+      terminationCriterion.OperatorGraph.AddOperator(seq);
+      terminationCriterion.OperatorGraph.InitialOperator = seq;
+      return terminationCriterion;
+    }
+
+    protected virtual IOperator CreateEvaluationOperator() {
+      return new EmptyOperator();
+    }
+
+    protected virtual IOperator CreateManipulationOperator() {
+      ChangeNodeTypeManipulation manipulator = new ChangeNodeTypeManipulation();
+      manipulator.Name = "Manipulator";
+      return manipulator;
+    }
+
+    protected virtual IOperator CreateCrossoverOperator() {
+      StandardCrossOver crossover = new StandardCrossOver();
+      crossover.Name = "Crossover";
+      return crossover;
+    }
+
+    protected virtual IOperator CreateSelectionOperator() {
+      TournamentSelector selector = new TournamentSelector();
+      selector.GetVariableInfo("Selected").ActualName = "Parents";
+      selector.GetVariable("GroupSize").Value = new IntData(7);
+      selector.Name = "Selector";
+      return selector;
+    }
+
+    #endregion
+
+    protected virtual IOperator CreatePostProcessingOperator() {
+      return new EmptyOperator();
+    }
+
+
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      AlgorithmBase clone = (AlgorithmBase)base.Clone(clonedObjects);
+      clonedObjects.Add(Guid, clone);
+      clone.engine = (SequentialEngine.SequentialEngine)Auxiliary.Clone(Engine, clonedObjects);
+      return clone;
+    }
+
+    protected virtual IOperator GetVariableInjector() {
+      CombinedOperator init = (CombinedOperator)GetInitializationOperator();
+      return init.OperatorGraph.InitialOperator.SubOperators[1];
+    }
+
+    protected virtual IOperator GetRandomInjector() {
+      CombinedOperator init = (CombinedOperator)GetInitializationOperator();
+      return init.OperatorGraph.InitialOperator.SubOperators[0];
+    }
+
+    protected virtual IOperator GetInitializationOperator() {
+      return algorithm.SubOperators[0];
+    }
+
+    #region Persistence Methods
+    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
+      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
+      node.AppendChild(PersistenceManager.Persist("Engine", Engine, document, persistedObjects));
+      return node;
+    }
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
+      base.Populate(node, restoredObjects);
+      engine = (SequentialEngine.SequentialEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
+    }
+    #endregion
+
+
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/HeuristicLab.GP.Algorithms-3.2.csproj
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/HeuristicLab.GP.Algorithms-3.2.csproj	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/HeuristicLab.GP.Algorithms-3.2.csproj	(revision 2341)
@@ -0,0 +1,182 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{3127719F-110E-4558-8845-98559DBB422D}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.GP.Algorithms</RootNamespace>
+    <AssemblyName>HeuristicLab.GP.Algorithms-3.2</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</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\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AlgorithmBase.cs" />
+    <Compile Include="HeuristicLabGpAlgorithmsPlugin.cs" />
+    <Compile Include="OffspringSelectionGP.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="OffSpringSelectionGpEditor.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="OffSpringSelectionGpEditor.Designer.cs">
+      <DependentUpon>OffSpringSelectionGpEditor.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="StandardGP.cs" />
+    <Compile Include="StandardGpEditor.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="StandardGpEditor.Designer.cs">
+      <DependentUpon>StandardGpEditor.cs</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.2\HeuristicLab.Core-3.2.csproj">
+      <Project>{F43B59AB-2B8C-4570-BC1E-15592086517C}</Project>
+      <Name>HeuristicLab.Core-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.2\HeuristicLab.Data-3.2.csproj">
+      <Project>{F473D9AF-3F09-4296-9F28-3C65118DAFFA}</Project>
+      <Name>HeuristicLab.Data-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Evolutionary\3.2\HeuristicLab.Evolutionary-3.2.csproj">
+      <Project>{F5614C53-153C-4A37-A608-121E1C087F07}</Project>
+      <Name>HeuristicLab.Evolutionary-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.GP.Operators\3.3\HeuristicLab.GP.Operators-3.3.csproj">
+      <Project>{45D11FBD-A71B-48D3-8A94-8EB0DFE8E06A}</Project>
+      <Name>HeuristicLab.GP.Operators-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.GP\3.3\HeuristicLab.GP-3.3.csproj">
+      <Project>{1F1CF3ED-374C-4288-995B-93F6B872F571}</Project>
+      <Name>HeuristicLab.GP-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Logging\3.2\HeuristicLab.Logging-3.2.csproj">
+      <Project>{4095C92C-5A4C-44BC-9963-5F384CF5CC3F}</Project>
+      <Name>HeuristicLab.Logging-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Operators\3.2\HeuristicLab.Operators-3.2.csproj">
+      <Project>{A9983BA2-B3B2-475E-8E2C-62050B71D1C5}</Project>
+      <Name>HeuristicLab.Operators-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.2\HeuristicLab.Random-3.2.csproj">
+      <Project>{47019A74-F7F7-482E-83AA-D3F4F777E879}</Project>
+      <Name>HeuristicLab.Random-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Selection.OffspringSelection\3.2\HeuristicLab.Selection.OffspringSelection-3.2.csproj">
+      <Project>{205898D3-2717-4686-AF17-52409B7EC0C6}</Project>
+      <Name>HeuristicLab.Selection.OffspringSelection-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Selection\3.2\HeuristicLab.Selection-3.2.csproj">
+      <Project>{F7CF0571-25CB-43D5-8443-0843A1E2861A}</Project>
+      <Name>HeuristicLab.Selection-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.SequentialEngine\3.2\HeuristicLab.SequentialEngine-3.2.csproj">
+      <Project>{B4BE8E53-BA06-4237-9A01-24255F880201}</Project>
+      <Name>HeuristicLab.SequentialEngine-3.2</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Properties\AssemblyInfo.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="OffSpringSelectionGpEditor.resx">
+      <DependentUpon>OffSpringSelectionGpEditor.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="StandardGpEditor.resx">
+      <DependentUpon>StandardGpEditor.cs</DependentUpon>
+    </EmbeddedResource>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/HeuristicLabGpAlgorithmsPlugin.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/HeuristicLabGpAlgorithmsPlugin.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/HeuristicLabGpAlgorithmsPlugin.cs	(revision 2341)
@@ -0,0 +1,32 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Text;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.GP.Algorithms {
+  [ClassInfo(Name = "HeuristicLab.GP.Algorithms-3.2")]
+  [PluginFile(Filename = "HeuristicLab.GP.Algorithms-3.2.dll", Filetype = PluginFileType.Assembly)]
+  public class HeuristicLabGpAlgorithmsPlugin : PluginBase {
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffSpringSelectionGpEditor.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffSpringSelectionGpEditor.Designer.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffSpringSelectionGpEditor.Designer.cs	(revision 2341)
@@ -0,0 +1,404 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.GP.Algorithms {
+  partial class OffspringSelectionGpEditor {
+    /// <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 (chooseOperatorDialog != null) chooseOperatorDialog.Dispose();
+      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.executeButton = new System.Windows.Forms.Button();
+      this.tabControl = new System.Windows.Forms.TabControl();
+      this.parametersTabPage = new System.Windows.Forms.TabPage();
+      this.selectionPressureTextBox = new System.Windows.Forms.TextBox();
+      this.selectionPressureLabel = new System.Windows.Forms.Label();
+      this.viewProblemInitializationButton = new System.Windows.Forms.Button();
+      this.setProblemInitializationButton = new System.Windows.Forms.Button();
+      this.problemInitializationTextBox = new System.Windows.Forms.TextBox();
+      this.setRandomSeedRandomlyCheckBox = new System.Windows.Forms.CheckBox();
+      this.elitesTextBox = new System.Windows.Forms.TextBox();
+      this.problemInitializationLabel = new System.Windows.Forms.Label();
+      this.elitesLabel = new System.Windows.Forms.Label();
+      this.mutationRateTextBox = new System.Windows.Forms.TextBox();
+      this.mutationRateLabel = new System.Windows.Forms.Label();
+      this.maximumEvaluatedSolutionsTextBox = new System.Windows.Forms.TextBox();
+      this.maxEvaluatedSolutionsLabel = new System.Windows.Forms.Label();
+      this.randomSeedTextBox = new System.Windows.Forms.TextBox();
+      this.populationSizeTextBox = new System.Windows.Forms.TextBox();
+      this.setRandomSeedRandomlyLabel = new System.Windows.Forms.Label();
+      this.randomSeedLabel = new System.Windows.Forms.Label();
+      this.populationSizeLabel = new System.Windows.Forms.Label();
+      this.scopesTabPage = new System.Windows.Forms.TabPage();
+      this.scopeView = new HeuristicLab.Core.ScopeView();
+      this.abortButton = new System.Windows.Forms.Button();
+      this.resetButton = new System.Windows.Forms.Button();
+      this.cloneEngineButton = new System.Windows.Forms.Button();
+      this.tabControl.SuspendLayout();
+      this.parametersTabPage.SuspendLayout();
+      this.scopesTabPage.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // executeButton
+      // 
+      this.executeButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.executeButton.Location = new System.Drawing.Point(0, 396);
+      this.executeButton.Name = "executeButton";
+      this.executeButton.Size = new System.Drawing.Size(75, 23);
+      this.executeButton.TabIndex = 1;
+      this.executeButton.Text = "&Execute";
+      this.executeButton.UseVisualStyleBackColor = true;
+      this.executeButton.Click += new System.EventHandler(this.executeButton_Click);
+      // 
+      // tabControl
+      // 
+      this.tabControl.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.tabControl.Controls.Add(this.parametersTabPage);
+      this.tabControl.Controls.Add(this.scopesTabPage);
+      this.tabControl.Location = new System.Drawing.Point(0, 0);
+      this.tabControl.Name = "tabControl";
+      this.tabControl.SelectedIndex = 0;
+      this.tabControl.Size = new System.Drawing.Size(526, 390);
+      this.tabControl.TabIndex = 0;
+      // 
+      // parametersTabPage
+      // 
+      this.parametersTabPage.Controls.Add(this.selectionPressureTextBox);
+      this.parametersTabPage.Controls.Add(this.selectionPressureLabel);
+      this.parametersTabPage.Controls.Add(this.viewProblemInitializationButton);
+      this.parametersTabPage.Controls.Add(this.setProblemInitializationButton);
+      this.parametersTabPage.Controls.Add(this.problemInitializationTextBox);
+      this.parametersTabPage.Controls.Add(this.setRandomSeedRandomlyCheckBox);
+      this.parametersTabPage.Controls.Add(this.elitesTextBox);
+      this.parametersTabPage.Controls.Add(this.problemInitializationLabel);
+      this.parametersTabPage.Controls.Add(this.elitesLabel);
+      this.parametersTabPage.Controls.Add(this.mutationRateTextBox);
+      this.parametersTabPage.Controls.Add(this.mutationRateLabel);
+      this.parametersTabPage.Controls.Add(this.maximumEvaluatedSolutionsTextBox);
+      this.parametersTabPage.Controls.Add(this.maxEvaluatedSolutionsLabel);
+      this.parametersTabPage.Controls.Add(this.randomSeedTextBox);
+      this.parametersTabPage.Controls.Add(this.populationSizeTextBox);
+      this.parametersTabPage.Controls.Add(this.setRandomSeedRandomlyLabel);
+      this.parametersTabPage.Controls.Add(this.randomSeedLabel);
+      this.parametersTabPage.Controls.Add(this.populationSizeLabel);
+      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
+      this.parametersTabPage.Name = "parametersTabPage";
+      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.parametersTabPage.Size = new System.Drawing.Size(518, 364);
+      this.parametersTabPage.TabIndex = 0;
+      this.parametersTabPage.Text = "Parameters";
+      this.parametersTabPage.UseVisualStyleBackColor = true;
+      // 
+      // selectionPressureTextBox
+      // 
+      this.selectionPressureTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.selectionPressureTextBox.Location = new System.Drawing.Point(218, 130);
+      this.selectionPressureTextBox.Name = "selectionPressureTextBox";
+      this.selectionPressureTextBox.Size = new System.Drawing.Size(186, 20);
+      this.selectionPressureTextBox.TabIndex = 17;
+      // 
+      // selectionPressureLabel
+      // 
+      this.selectionPressureLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.selectionPressureLabel.AutoSize = true;
+      this.selectionPressureLabel.Location = new System.Drawing.Point(65, 133);
+      this.selectionPressureLabel.Name = "selectionPressureLabel";
+      this.selectionPressureLabel.Size = new System.Drawing.Size(145, 13);
+      this.selectionPressureLabel.TabIndex = 16;
+      this.selectionPressureLabel.Text = "Maximum &Selection Pressure:";
+      // 
+      // viewProblemInitializationButton
+      // 
+      this.viewProblemInitializationButton.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.viewProblemInitializationButton.Location = new System.Drawing.Point(410, 241);
+      this.viewProblemInitializationButton.Name = "viewProblemInitializationButton";
+      this.viewProblemInitializationButton.Size = new System.Drawing.Size(53, 20);
+      this.viewProblemInitializationButton.TabIndex = 14;
+      this.viewProblemInitializationButton.Text = "View...";
+      this.viewProblemInitializationButton.UseVisualStyleBackColor = true;
+      this.viewProblemInitializationButton.Click += new System.EventHandler(this.viewProblemInjectorButton_Click);
+      // 
+      // setProblemInitializationButton
+      // 
+      this.setProblemInitializationButton.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.setProblemInitializationButton.Location = new System.Drawing.Point(469, 241);
+      this.setProblemInitializationButton.Name = "setProblemInitializationButton";
+      this.setProblemInitializationButton.Size = new System.Drawing.Size(43, 20);
+      this.setProblemInitializationButton.TabIndex = 15;
+      this.setProblemInitializationButton.Text = "Set...";
+      this.setProblemInitializationButton.UseVisualStyleBackColor = true;
+      this.setProblemInitializationButton.Click += new System.EventHandler(this.setProblemInitializationButton_Click);
+      // 
+      // problemInitializationTextBox
+      // 
+      this.problemInitializationTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.problemInitializationTextBox.Location = new System.Drawing.Point(218, 241);
+      this.problemInitializationTextBox.Name = "problemInitializationTextBox";
+      this.problemInitializationTextBox.ReadOnly = true;
+      this.problemInitializationTextBox.Size = new System.Drawing.Size(186, 20);
+      this.problemInitializationTextBox.TabIndex = 13;
+      // 
+      // setRandomSeedRandomlyCheckBox
+      // 
+      this.setRandomSeedRandomlyCheckBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.setRandomSeedRandomlyCheckBox.AutoSize = true;
+      this.setRandomSeedRandomlyCheckBox.Location = new System.Drawing.Point(218, 6);
+      this.setRandomSeedRandomlyCheckBox.Name = "setRandomSeedRandomlyCheckBox";
+      this.setRandomSeedRandomlyCheckBox.Size = new System.Drawing.Size(15, 14);
+      this.setRandomSeedRandomlyCheckBox.TabIndex = 1;
+      this.setRandomSeedRandomlyCheckBox.UseVisualStyleBackColor = true;
+      this.setRandomSeedRandomlyCheckBox.CheckedChanged += new System.EventHandler(this.setRandomSeedRandomlyCheckBox_CheckedChanged);
+      // 
+      // elitesTextBox
+      // 
+      this.elitesTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.elitesTextBox.Location = new System.Drawing.Point(218, 182);
+      this.elitesTextBox.Name = "elitesTextBox";
+      this.elitesTextBox.Size = new System.Drawing.Size(186, 20);
+      this.elitesTextBox.TabIndex = 11;
+      // 
+      // problemInitializationLabel
+      // 
+      this.problemInitializationLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.problemInitializationLabel.AutoSize = true;
+      this.problemInitializationLabel.Location = new System.Drawing.Point(65, 244);
+      this.problemInitializationLabel.Name = "problemInitializationLabel";
+      this.problemInitializationLabel.Size = new System.Drawing.Size(105, 13);
+      this.problemInitializationLabel.TabIndex = 12;
+      this.problemInitializationLabel.Text = "&Problem Initialization:";
+      // 
+      // elitesLabel
+      // 
+      this.elitesLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.elitesLabel.AutoSize = true;
+      this.elitesLabel.Location = new System.Drawing.Point(66, 185);
+      this.elitesLabel.Name = "elitesLabel";
+      this.elitesLabel.Size = new System.Drawing.Size(35, 13);
+      this.elitesLabel.TabIndex = 10;
+      this.elitesLabel.Text = "&Elites:";
+      // 
+      // mutationRateTextBox
+      // 
+      this.mutationRateTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.mutationRateTextBox.Location = new System.Drawing.Point(218, 156);
+      this.mutationRateTextBox.Name = "mutationRateTextBox";
+      this.mutationRateTextBox.Size = new System.Drawing.Size(186, 20);
+      this.mutationRateTextBox.TabIndex = 9;
+      // 
+      // mutationRateLabel
+      // 
+      this.mutationRateLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.mutationRateLabel.AutoSize = true;
+      this.mutationRateLabel.Location = new System.Drawing.Point(66, 159);
+      this.mutationRateLabel.Name = "mutationRateLabel";
+      this.mutationRateLabel.Size = new System.Drawing.Size(77, 13);
+      this.mutationRateLabel.TabIndex = 8;
+      this.mutationRateLabel.Text = "&Mutation Rate:";
+      // 
+      // maximumEvaluatedSolutionsTextBox
+      // 
+      this.maximumEvaluatedSolutionsTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.maximumEvaluatedSolutionsTextBox.Location = new System.Drawing.Point(218, 104);
+      this.maximumEvaluatedSolutionsTextBox.Name = "maximumEvaluatedSolutionsTextBox";
+      this.maximumEvaluatedSolutionsTextBox.Size = new System.Drawing.Size(186, 20);
+      this.maximumEvaluatedSolutionsTextBox.TabIndex = 7;
+      // 
+      // maxEvaluatedSolutionsLabel
+      // 
+      this.maxEvaluatedSolutionsLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.maxEvaluatedSolutionsLabel.AutoSize = true;
+      this.maxEvaluatedSolutionsLabel.Location = new System.Drawing.Point(65, 107);
+      this.maxEvaluatedSolutionsLabel.Name = "maxEvaluatedSolutionsLabel";
+      this.maxEvaluatedSolutionsLabel.Size = new System.Drawing.Size(130, 13);
+      this.maxEvaluatedSolutionsLabel.TabIndex = 6;
+      this.maxEvaluatedSolutionsLabel.Text = "Max. E&valuated Solutions:";
+      // 
+      // randomSeedTextBox
+      // 
+      this.randomSeedTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.randomSeedTextBox.Location = new System.Drawing.Point(218, 26);
+      this.randomSeedTextBox.Name = "randomSeedTextBox";
+      this.randomSeedTextBox.Size = new System.Drawing.Size(186, 20);
+      this.randomSeedTextBox.TabIndex = 3;
+      // 
+      // populationSizeTextBox
+      // 
+      this.populationSizeTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.populationSizeTextBox.Location = new System.Drawing.Point(218, 78);
+      this.populationSizeTextBox.Name = "populationSizeTextBox";
+      this.populationSizeTextBox.Size = new System.Drawing.Size(186, 20);
+      this.populationSizeTextBox.TabIndex = 5;
+      // 
+      // setRandomSeedRandomlyLabel
+      // 
+      this.setRandomSeedRandomlyLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.setRandomSeedRandomlyLabel.AutoSize = true;
+      this.setRandomSeedRandomlyLabel.Location = new System.Drawing.Point(65, 6);
+      this.setRandomSeedRandomlyLabel.Name = "setRandomSeedRandomlyLabel";
+      this.setRandomSeedRandomlyLabel.Size = new System.Drawing.Size(147, 13);
+      this.setRandomSeedRandomlyLabel.TabIndex = 0;
+      this.setRandomSeedRandomlyLabel.Text = "Set &Random Seed Randomly:";
+      // 
+      // randomSeedLabel
+      // 
+      this.randomSeedLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.randomSeedLabel.AutoSize = true;
+      this.randomSeedLabel.Location = new System.Drawing.Point(65, 29);
+      this.randomSeedLabel.Name = "randomSeedLabel";
+      this.randomSeedLabel.Size = new System.Drawing.Size(78, 13);
+      this.randomSeedLabel.TabIndex = 2;
+      this.randomSeedLabel.Text = "&Random Seed:";
+      // 
+      // populationSizeLabel
+      // 
+      this.populationSizeLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.populationSizeLabel.AutoSize = true;
+      this.populationSizeLabel.Location = new System.Drawing.Point(65, 81);
+      this.populationSizeLabel.Name = "populationSizeLabel";
+      this.populationSizeLabel.Size = new System.Drawing.Size(83, 13);
+      this.populationSizeLabel.TabIndex = 4;
+      this.populationSizeLabel.Text = "&Population Size:";
+      // 
+      // scopesTabPage
+      // 
+      this.scopesTabPage.Controls.Add(this.scopeView);
+      this.scopesTabPage.Location = new System.Drawing.Point(4, 22);
+      this.scopesTabPage.Name = "scopesTabPage";
+      this.scopesTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.scopesTabPage.Size = new System.Drawing.Size(518, 364);
+      this.scopesTabPage.TabIndex = 2;
+      this.scopesTabPage.Text = "Scopes";
+      this.scopesTabPage.UseVisualStyleBackColor = true;
+      // 
+      // scopeView
+      // 
+      this.scopeView.Caption = "Scope";
+      this.scopeView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.scopeView.Location = new System.Drawing.Point(3, 3);
+      this.scopeView.Name = "scopeView";
+      this.scopeView.Scope = null;
+      this.scopeView.Size = new System.Drawing.Size(512, 358);
+      this.scopeView.TabIndex = 0;
+      // 
+      // abortButton
+      // 
+      this.abortButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.abortButton.Enabled = false;
+      this.abortButton.Location = new System.Drawing.Point(81, 396);
+      this.abortButton.Name = "abortButton";
+      this.abortButton.Size = new System.Drawing.Size(75, 23);
+      this.abortButton.TabIndex = 2;
+      this.abortButton.Text = "&Abort";
+      this.abortButton.UseVisualStyleBackColor = true;
+      this.abortButton.Click += new System.EventHandler(this.abortButton_Click);
+      // 
+      // resetButton
+      // 
+      this.resetButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.resetButton.Location = new System.Drawing.Point(162, 396);
+      this.resetButton.Name = "resetButton";
+      this.resetButton.Size = new System.Drawing.Size(75, 23);
+      this.resetButton.TabIndex = 3;
+      this.resetButton.Text = "&Reset";
+      this.resetButton.UseVisualStyleBackColor = true;
+      this.resetButton.Click += new System.EventHandler(this.resetButton_Click);
+      // 
+      // cloneEngineButton
+      // 
+      this.cloneEngineButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+      this.cloneEngineButton.Location = new System.Drawing.Point(420, 396);
+      this.cloneEngineButton.Name = "cloneEngineButton";
+      this.cloneEngineButton.Size = new System.Drawing.Size(106, 23);
+      this.cloneEngineButton.TabIndex = 4;
+      this.cloneEngineButton.Text = "&Clone Engine...";
+      this.cloneEngineButton.UseVisualStyleBackColor = true;
+      this.cloneEngineButton.Click += new System.EventHandler(this.cloneEngineButton_Click);
+      // 
+      // OffspringSelectionGpEditor
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.tabControl);
+      this.Controls.Add(this.cloneEngineButton);
+      this.Controls.Add(this.resetButton);
+      this.Controls.Add(this.abortButton);
+      this.Controls.Add(this.executeButton);
+      this.Name = "OffspringSelectionGpEditor";
+      this.Size = new System.Drawing.Size(526, 419);
+      this.tabControl.ResumeLayout(false);
+      this.parametersTabPage.ResumeLayout(false);
+      this.parametersTabPage.PerformLayout();
+      this.scopesTabPage.ResumeLayout(false);
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.Button executeButton;
+    protected System.Windows.Forms.TabControl tabControl;
+    protected System.Windows.Forms.TabPage parametersTabPage;
+    private System.Windows.Forms.Button abortButton;
+    private System.Windows.Forms.Button resetButton;
+    private System.Windows.Forms.TextBox mutationRateTextBox;
+    private System.Windows.Forms.Label mutationRateLabel;
+    private System.Windows.Forms.TextBox populationSizeTextBox;
+    private System.Windows.Forms.Label populationSizeLabel;
+    private System.Windows.Forms.TabPage scopesTabPage;
+    private System.Windows.Forms.TextBox maximumEvaluatedSolutionsTextBox;
+    private System.Windows.Forms.Label maxEvaluatedSolutionsLabel;
+    private System.Windows.Forms.TextBox elitesTextBox;
+    private System.Windows.Forms.Label elitesLabel;
+    private System.Windows.Forms.TextBox randomSeedTextBox;
+    private System.Windows.Forms.Label setRandomSeedRandomlyLabel;
+    private System.Windows.Forms.Label randomSeedLabel;
+    private System.Windows.Forms.CheckBox setRandomSeedRandomlyCheckBox;
+    private System.Windows.Forms.Label problemInitializationLabel;
+    private System.Windows.Forms.Button cloneEngineButton;
+    private System.Windows.Forms.TextBox problemInitializationTextBox;
+    private System.Windows.Forms.Button setProblemInitializationButton;
+    private HeuristicLab.Core.ScopeView scopeView;
+    private System.Windows.Forms.Button viewProblemInitializationButton;
+    private System.Windows.Forms.TextBox selectionPressureTextBox;
+    private System.Windows.Forms.Label selectionPressureLabel;
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffSpringSelectionGpEditor.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffSpringSelectionGpEditor.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffSpringSelectionGpEditor.cs	(revision 2341)
@@ -0,0 +1,137 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.PluginInfrastructure;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.GP.Algorithms {
+  public partial class OffspringSelectionGpEditor : EditorBase {
+    private ChooseOperatorDialog chooseOperatorDialog;
+
+    public OffspringSelectionGP OffspringSelectionGP {
+      get { return (OffspringSelectionGP)Item; }
+      set { base.Item = value; }
+    }
+
+    public OffspringSelectionGpEditor() {
+      InitializeComponent();
+    }
+    public OffspringSelectionGpEditor(OffspringSelectionGP osgp)
+      : this() {
+      OffspringSelectionGP = osgp;
+    }
+
+    protected override void RemoveItemEvents() {
+      OffspringSelectionGP.Engine.ExceptionOccurred -= new EventHandler<ExceptionEventArgs>(Engine_ExceptionOccurred);
+      OffspringSelectionGP.Engine.Finished -= new EventHandler(Engine_Finished);
+      scopeView.Scope = null;
+      base.RemoveItemEvents();
+    }
+
+    protected override void AddItemEvents() {
+      base.AddItemEvents();
+      OffspringSelectionGP.Engine.ExceptionOccurred += new EventHandler<ExceptionEventArgs>(Engine_ExceptionOccurred);
+      OffspringSelectionGP.Engine.Finished += new EventHandler(Engine_Finished);
+      SetDataBinding();
+      scopeView.Scope = OffspringSelectionGP.Engine.GlobalScope;
+    }
+
+    protected override void UpdateControls() {
+      base.UpdateControls();
+      if (OffspringSelectionGP == null) {
+        tabControl.Enabled = false;
+      } else {
+        tabControl.Enabled = true;
+        problemInitializationTextBox.Text = OffspringSelectionGP.ProblemInjector.GetType().Name;
+      }
+    }
+
+    protected virtual void SetDataBinding() {
+      setRandomSeedRandomlyCheckBox.DataBindings.Add("Checked", OffspringSelectionGP, "SetSeedRandomly");
+      randomSeedTextBox.DataBindings.Add("Text", OffspringSelectionGP, "RandomSeed");
+      populationSizeTextBox.DataBindings.Add("Text", OffspringSelectionGP, "PopulationSize");
+      maximumEvaluatedSolutionsTextBox.DataBindings.Add("Text", OffspringSelectionGP, "MaxEvaluatedSolutions");
+      selectionPressureTextBox.DataBindings.Add("Text", OffspringSelectionGP, "SelectionPressureLimit");
+      mutationRateTextBox.DataBindings.Add("Text", OffspringSelectionGP, "MutationRate");
+      elitesTextBox.DataBindings.Add("Text", OffspringSelectionGP, "Elites");
+    }
+
+    #region Button Events
+    private void viewProblemInjectorButton_Click(object sender, EventArgs e) {
+      IView view = OffspringSelectionGP.ProblemInjector.CreateView();
+      if(view != null)
+        PluginManager.ControlManager.ShowControl(view);
+    }
+
+    private void setProblemInitializationButton_Click(object sender, EventArgs e) {
+      if (chooseOperatorDialog == null) chooseOperatorDialog = new ChooseOperatorDialog();
+      if (chooseOperatorDialog.ShowDialog(this) == DialogResult.OK) {
+        OffspringSelectionGP.ProblemInjector = chooseOperatorDialog.Operator;
+        problemInitializationTextBox.Text = OffspringSelectionGP.ProblemInjector.GetType().Name;
+      }
+    }
+    private void executeButton_Click(object sender, EventArgs e) {
+      executeButton.Enabled = false;
+      abortButton.Enabled = true;
+      resetButton.Enabled = false;
+      OffspringSelectionGP.Engine.Execute();
+    }
+    private void abortButton_Click(object sender, EventArgs e) {
+      OffspringSelectionGP.Engine.Abort();
+    }
+    private void resetButton_Click(object sender, EventArgs e) {
+      OffspringSelectionGP.Engine.Reset();
+    }
+    private void cloneEngineButton_Click(object sender, EventArgs e) {
+      IEngine clone = (IEngine)OffspringSelectionGP.Engine.Clone();
+      IEditor editor = ((IEditable)clone).CreateEditor();
+      PluginManager.ControlManager.ShowControl(editor);
+    }
+    #endregion
+
+    #region Engine Events
+    private delegate void OnExceptionEventDelegate(object sender, ExceptionEventArgs e);
+    private void Engine_ExceptionOccurred(object sender, ExceptionEventArgs e) {
+      if (InvokeRequired)
+        Invoke(new OnExceptionEventDelegate(Engine_ExceptionOccurred), sender, e);
+      else
+        Auxiliary.ShowErrorMessageBox(e.Exception);
+    }
+    private void Engine_Finished(object sender, EventArgs e) {
+      if(InvokeRequired)
+        Invoke((EventHandler)Engine_Finished, sender, e);
+      else {
+        scopeView.Refresh();
+        executeButton.Enabled = true;
+        abortButton.Enabled = false;
+        resetButton.Enabled = true;
+      }
+    }
+    #endregion
+
+    private void setRandomSeedRandomlyCheckBox_CheckedChanged(object sender, EventArgs e) {
+      randomSeedTextBox.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
+      randomSeedLabel.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffSpringSelectionGpEditor.resx
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffSpringSelectionGpEditor.resx	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffSpringSelectionGpEditor.resx	(revision 2341)
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffspringSelectionGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffspringSelectionGP.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/OffspringSelectionGP.cs	(revision 2341)
@@ -0,0 +1,244 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Data;
+using HeuristicLab.Evolutionary;
+using HeuristicLab.Logging;
+using HeuristicLab.Operators;
+using HeuristicLab.Selection;
+using HeuristicLab.Selection.OffspringSelection;
+
+namespace HeuristicLab.GP.Algorithms {
+  public class OffspringSelectionGP : AlgorithmBase, IEditable {
+    public override string Name { get { return "OffspringSelectionGP"; } }
+
+    public virtual int MaxEvaluatedSolutions {
+      get { return GetVariableInjector().GetVariable("MaxEvaluatedSolutions").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxEvaluatedSolutions").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual double SelectionPressureLimit {
+      get { return GetVariableInjector().GetVariable("SelectionPressureLimit").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("SelectionPressureLimit").GetValue<DoubleData>().Data = value; }
+    }
+
+    public virtual double ComparisonFactor {
+      get { return GetVariableInjector().GetVariable("ComparisonFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("ComparisonFactor").GetValue<DoubleData>().Data = value; }
+    }
+
+    public virtual double SuccessRatioLimit {
+      get { return GetVariableInjector().GetVariable("SuccessRatioLimit").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("SuccessRatioLimit").GetValue<DoubleData>().Data = value; }
+    }
+
+    public OffspringSelectionGP()
+      : base() {
+      PopulationSize = 1000;
+      Parents = 20;
+      MaxGenerations = 10000; // something large to make sure we either stop because of max-evaluated soltions or selection pressure limit
+      MaxEvaluatedSolutions = 5000000;
+      SelectionPressureLimit = 400;
+      ComparisonFactor = 1.0;
+      SuccessRatioLimit = 1.0;
+    }
+
+    protected override VariableInjector CreateGlobalInjector() {
+      VariableInjector injector = base.CreateGlobalInjector();
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxEvaluatedSolutions", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("ComparisonFactor", new DoubleData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("SelectionPressureLimit", new DoubleData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("SuccessRatioLimit", new DoubleData()));
+      return injector;
+    }
+
+    protected override IOperator CreateSelectionOperator() {
+      CombinedOperator selector = new CombinedOperator();
+      selector.Name = "Selector";
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.Name = "Selector";
+      EmptyOperator emptyOp = new EmptyOperator();
+      ProportionalSelector femaleSelector = new ProportionalSelector();
+      femaleSelector.GetVariableInfo("Selected").ActualName = "Parents";
+      femaleSelector.GetVariableValue<BoolData>("CopySelected", null, false).Data = true;
+
+      RandomSelector maleSelector = new RandomSelector();
+      maleSelector.GetVariableInfo("Selected").ActualName = "Parents";
+      maleSelector.GetVariableValue<BoolData>("CopySelected", null, false).Data = true;
+      SequentialSubScopesProcessor seqSubScopesProc = new SequentialSubScopesProcessor();
+      RightChildReducer rightChildReducer = new RightChildReducer();
+      SubScopesMixer mixer = new SubScopesMixer();
+
+      seqSubScopesProc.AddSubOperator(femaleSelector);
+      seqSubScopesProc.AddSubOperator(emptyOp);
+
+      seq.AddSubOperator(maleSelector);
+      seq.AddSubOperator(seqSubScopesProc);
+      seq.AddSubOperator(rightChildReducer);
+      seq.AddSubOperator(mixer);
+
+      selector.OperatorGraph.AddOperator(seq);
+      selector.OperatorGraph.InitialOperator = seq;
+      return selector;
+    }
+
+    protected override IOperator CreateChildCreater() {
+      CombinedOperator childCreater = new CombinedOperator();
+      childCreater.Name = "Create children";
+      SequentialProcessor main = new SequentialProcessor();
+      SequentialProcessor seq = new SequentialProcessor();
+      SequentialProcessor offspringSelectionSeq = new SequentialProcessor();
+      OperatorExtractor selector = new OperatorExtractor();
+      selector.Name = "Selector (extr.)";
+      selector.GetVariableInfo("Operator").ActualName = "Selector";
+      SequentialSubScopesProcessor seqSubScopesProc = new SequentialSubScopesProcessor();
+      EmptyOperator emptyOp = new EmptyOperator();
+      OffspringSelector offspringSelector = new OffspringSelector();
+      ChildrenInitializer childInitializer = new ChildrenInitializer();
+      UniformSequentialSubScopesProcessor individualProc = new UniformSequentialSubScopesProcessor();
+      SequentialProcessor individualSeqProc = new SequentialProcessor();
+      OperatorExtractor crossover = new OperatorExtractor();
+      crossover.Name = "Crossover (extr.)";
+      crossover.GetVariableInfo("Operator").ActualName = "Crossover";
+      StochasticBranch cond = new StochasticBranch();
+      cond.GetVariableInfo("Probability").ActualName = "MutationRate";
+      OperatorExtractor manipulator = new OperatorExtractor();
+      manipulator.Name = "Manipulator (extr.)";
+      manipulator.GetVariableInfo("Operator").ActualName = "Manipulator";
+      OperatorExtractor evaluator = new OperatorExtractor();
+      evaluator.Name = "Evaluator (extr.)";
+      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
+      Counter evalCounter = new Counter();
+      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
+      WeightedOffspringFitnessComparer offspringFitnessComparer = new WeightedOffspringFitnessComparer();
+      SubScopesRemover parentScopesRemover = new SubScopesRemover();
+
+      Sorter sorter = new Sorter();
+      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
+      sorter.GetVariableInfo("Value").ActualName = "Quality";
+
+      main.AddSubOperator(seq);
+      seq.AddSubOperator(selector);
+      seq.AddSubOperator(seqSubScopesProc);
+      seqSubScopesProc.AddSubOperator(emptyOp);
+      seqSubScopesProc.AddSubOperator(offspringSelectionSeq);
+      seq.AddSubOperator(offspringSelector);
+      offspringSelector.AddSubOperator(seq);
+
+      offspringSelectionSeq.AddSubOperator(childInitializer);
+      offspringSelectionSeq.AddSubOperator(individualProc);
+      offspringSelectionSeq.AddSubOperator(sorter);
+
+      individualProc.AddSubOperator(individualSeqProc);
+      individualSeqProc.AddSubOperator(crossover);
+      individualSeqProc.AddSubOperator(cond);
+      cond.AddSubOperator(manipulator);
+      individualSeqProc.AddSubOperator(evaluator);
+      individualSeqProc.AddSubOperator(evalCounter);
+      individualSeqProc.AddSubOperator(offspringFitnessComparer);
+      individualSeqProc.AddSubOperator(parentScopesRemover);
+
+      SequentialSubScopesProcessor seqSubScopesProc2 = new SequentialSubScopesProcessor();
+      main.AddSubOperator(seqSubScopesProc2);
+      seqSubScopesProc2.AddSubOperator(emptyOp);
+      seqSubScopesProc2.AddSubOperator(sorter);
+
+      childCreater.OperatorGraph.AddOperator(main);
+      childCreater.OperatorGraph.InitialOperator = main;
+      return childCreater;
+    }
+
+    protected override IOperator CreateTerminationCondition() {
+      CombinedOperator terminationCritertion = new CombinedOperator();
+      terminationCritertion.Name = "TerminationCondition";
+      GreaterThanComparator selPresComparator = new GreaterThanComparator();
+      selPresComparator.GetVariableInfo("LeftSide").ActualName = "SelectionPressure";
+      selPresComparator.GetVariableInfo("RightSide").ActualName = "SelectionPressureLimit";
+      selPresComparator.GetVariableInfo("Result").ActualName = "TerminationCriterion";
+
+      IOperator baseAndSelPresTerminationCriterion = CombineTerminationCriterions(base.CreateTerminationCondition(), selPresComparator);
+
+      GreaterThanComparator evalSolutionsComparer = new GreaterThanComparator();
+      evalSolutionsComparer.GetVariableInfo("LeftSide").ActualName = "EvaluatedSolutions";
+      evalSolutionsComparer.GetVariableInfo("RightSide").ActualName = "MaxEvaluatedSolutions";
+      evalSolutionsComparer.GetVariableInfo("Result").ActualName = "TerminationCriterion";
+
+      IOperator combinedTerminationCritertion = CombineTerminationCriterions(baseAndSelPresTerminationCriterion, evalSolutionsComparer);
+
+      terminationCritertion.OperatorGraph.AddOperator(combinedTerminationCritertion);
+      terminationCritertion.OperatorGraph.InitialOperator = combinedTerminationCritertion;
+      return terminationCritertion;
+    }
+
+    private IOperator CombineTerminationCriterions(IOperator criterion1, IOperator criterion2) {
+      ConditionalBranch branch = new ConditionalBranch();
+      branch.GetVariableInfo("Condition").ActualName = "TerminationCriterion";
+      branch.AddSubOperator(new EmptyOperator());
+      branch.AddSubOperator(criterion2);
+
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(criterion1);
+      seq.AddSubOperator(branch);
+
+      return seq;
+    }
+
+    protected override IOperator CreateLoggingOperator() {
+      CombinedOperator loggingOperator = new CombinedOperator();
+      loggingOperator.Name = "Logging";
+      SequentialProcessor seq = new SequentialProcessor();
+
+      DataCollector collector = new DataCollector();
+      ItemList<StringData> names = collector.GetVariable("VariableNames").GetValue<ItemList<StringData>>();
+      names.Add(new StringData("BestQuality"));
+      names.Add(new StringData("AverageQuality"));
+      names.Add(new StringData("WorstQuality"));
+      names.Add(new StringData("EvaluatedSolutions"));
+      names.Add(new StringData("SelectionPressure"));
+      QualityLogger qualityLogger = new QualityLogger();
+      seq.AddSubOperator(collector);
+      seq.AddSubOperator(qualityLogger);
+
+      loggingOperator.OperatorGraph.AddOperator(seq);
+      loggingOperator.OperatorGraph.InitialOperator = seq;
+      return loggingOperator;
+    }
+
+    public virtual IEditor CreateEditor() {
+      return new OffspringSelectionGpEditor(this);
+    }
+
+    public override IView CreateView() {
+      return new OffspringSelectionGpEditor(this);
+    }
+
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      OffspringSelectionGP clone = (OffspringSelectionGP)base.Clone(clonedObjects);
+      clone.SelectionPressureLimit = SelectionPressureLimit;
+      clone.SuccessRatioLimit = SuccessRatioLimit;
+      clone.ComparisonFactor = ComparisonFactor;
+      return clone;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/Properties/AssemblyInfo.frame
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/Properties/AssemblyInfo.frame	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/Properties/AssemblyInfo.frame	(revision 2341)
@@ -0,0 +1,58 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.CompilerServices;
+using System.Runtime.InteropServices;
+using HeuristicLab.PluginInfrastructure;
+
+// 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.GP.Algorithms")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2008 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("863021a4-3cde-48be-8af6-dac1077f5fb5")]
+
+// 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 Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("3.2.0.$WCREV$")]
+[assembly: AssemblyFileVersion("3.2.0.$WCREV$")]
+[assembly: AssemblyBuildDate("$WCNOW$")]
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGP.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGP.cs	(revision 2341)
@@ -0,0 +1,132 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Operators;
+using HeuristicLab.Selection;
+using HeuristicLab.Logging;
+using HeuristicLab.Data;
+using HeuristicLab.GP.Operators;
+
+namespace HeuristicLab.GP.Algorithms {
+  public class StandardGP : AlgorithmBase, IEditable {
+
+    public override string Name { get { return "StandardGP"; } }
+    public virtual int TournamentSize {
+      get { return GetVariableInjector().GetVariable("TournamentSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("TournamentSize").GetValue<IntData>().Data = value; }
+    }
+
+    public double FullTreeShakingFactor {
+      get { return GetVariableInjector().GetVariable("FullTreeShakingFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("FullTreeShakingFactor").GetValue<DoubleData>().Data = value; }
+    }
+
+    public double OnePointShakingFactor {
+      get { return GetVariableInjector().GetVariable("OnePointShakingFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("OnePointShakingFactor").GetValue<DoubleData>().Data = value; }
+    }
+
+    public override int PopulationSize {
+      get {
+        return base.PopulationSize;
+      }
+      set {
+        base.PopulationSize = value;
+        Parents = 2 * value;
+      }
+    }
+
+    public StandardGP()
+      : base() {
+      PopulationSize = 10000;
+      MaxGenerations = 500;
+      TournamentSize = 7;
+      MutationRate = 0.15;
+      Elites = 1;
+      MaxTreeSize = 100;
+      MaxTreeHeight = 10;
+      FullTreeShakingFactor = 0.1;
+      OnePointShakingFactor = 1.0;
+      SetSeedRandomly = true;
+    }
+
+    protected override IOperator CreateSelectionOperator() {
+      TournamentSelector selector = new TournamentSelector();
+      selector.Name = "Selector";
+      selector.GetVariableInfo("Selected").ActualName = "Parents";
+      selector.GetVariableInfo("GroupSize").Local = false;
+      selector.RemoveVariable("GroupSize");
+      selector.GetVariableInfo("GroupSize").ActualName = "TournamentSize";
+      return selector;
+    }
+
+    protected override VariableInjector CreateGlobalInjector() {
+      VariableInjector globalInjector = base.CreateGlobalInjector();
+      globalInjector.AddVariable(new HeuristicLab.Core.Variable("TournamentSize", new IntData()));
+      globalInjector.AddVariable(new HeuristicLab.Core.Variable("FullTreeShakingFactor", new DoubleData()));
+      globalInjector.AddVariable(new HeuristicLab.Core.Variable("OnePointShakingFactor", new DoubleData()));
+      return globalInjector;
+    }
+
+    protected override IOperator CreateManipulationOperator() {
+      CombinedOperator manipulator = new CombinedOperator();
+      manipulator.Name = "Manipulator";
+      StochasticMultiBranch multibranch = new StochasticMultiBranch();
+      FullTreeShaker fullTreeShaker = new FullTreeShaker();
+      fullTreeShaker.GetVariableInfo("ShakingFactor").ActualName = "FullTreeShakingFactor";
+
+      OnePointShaker onepointShaker = new OnePointShaker();
+      onepointShaker.GetVariableInfo("ShakingFactor").ActualName = "OnePointShakingFactor";
+      ChangeNodeTypeManipulation changeNodeTypeManipulation = new ChangeNodeTypeManipulation();
+      CutOutNodeManipulation cutOutNodeManipulation = new CutOutNodeManipulation();
+      DeleteSubTreeManipulation deleteSubTreeManipulation = new DeleteSubTreeManipulation();
+      SubstituteSubTreeManipulation substituteSubTreeManipulation = new SubstituteSubTreeManipulation();
+
+      IOperator[] manipulators = new IOperator[] {
+        onepointShaker, fullTreeShaker,
+        changeNodeTypeManipulation,
+        cutOutNodeManipulation,
+        deleteSubTreeManipulation,
+        substituteSubTreeManipulation};
+
+      DoubleArrayData probabilities = new DoubleArrayData(new double[manipulators.Length]);
+      for (int i = 0; i < manipulators.Length; i++) {
+        probabilities.Data[i] = 1.0;
+        multibranch.AddSubOperator(manipulators[i]);
+      }
+      multibranch.GetVariableInfo("Probabilities").Local = true;
+      multibranch.AddVariable(new HeuristicLab.Core.Variable("Probabilities", probabilities));
+
+      manipulator.OperatorGraph.AddOperator(multibranch);
+      manipulator.OperatorGraph.InitialOperator = multibranch;
+      return manipulator;
+    }
+
+    public virtual IEditor CreateEditor() {
+      return new StandardGpEditor(this);
+    }
+
+    public override IView CreateView() {
+      return new StandardGpEditor(this);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGpEditor.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGpEditor.Designer.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGpEditor.Designer.cs	(revision 2341)
@@ -0,0 +1,380 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.GP.Algorithms {
+  partial class StandardGpEditor {
+    /// <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 (chooseOperatorDialog != null) chooseOperatorDialog.Dispose();
+      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.executeButton = new System.Windows.Forms.Button();
+      this.tabControl = new System.Windows.Forms.TabControl();
+      this.parametersTabPage = new System.Windows.Forms.TabPage();
+      this.viewProblemInitializationButton = new System.Windows.Forms.Button();
+      this.setProblemInitializationButton = new System.Windows.Forms.Button();
+      this.problemInitializationTextBox = new System.Windows.Forms.TextBox();
+      this.setRandomSeedRandomlyCheckBox = new System.Windows.Forms.CheckBox();
+      this.elitesTextBox = new System.Windows.Forms.TextBox();
+      this.problemInitializationLabel = new System.Windows.Forms.Label();
+      this.elitesLabel = new System.Windows.Forms.Label();
+      this.mutationRateTextBox = new System.Windows.Forms.TextBox();
+      this.mutationRateLabel = new System.Windows.Forms.Label();
+      this.maximumGenerationsTextBox = new System.Windows.Forms.TextBox();
+      this.maximumGenerationsLabel = new System.Windows.Forms.Label();
+      this.randomSeedTextBox = new System.Windows.Forms.TextBox();
+      this.populationSizeTextBox = new System.Windows.Forms.TextBox();
+      this.setRandomSeedRandomlyLabel = new System.Windows.Forms.Label();
+      this.randomSeedLabel = new System.Windows.Forms.Label();
+      this.populationSizeLabel = new System.Windows.Forms.Label();
+      this.scopesTabPage = new System.Windows.Forms.TabPage();
+      this.scopeView = new HeuristicLab.Core.ScopeView();
+      this.abortButton = new System.Windows.Forms.Button();
+      this.resetButton = new System.Windows.Forms.Button();
+      this.cloneEngineButton = new System.Windows.Forms.Button();
+      this.tabControl.SuspendLayout();
+      this.parametersTabPage.SuspendLayout();
+      this.scopesTabPage.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // executeButton
+      // 
+      this.executeButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.executeButton.Location = new System.Drawing.Point(0, 396);
+      this.executeButton.Name = "executeButton";
+      this.executeButton.Size = new System.Drawing.Size(75, 23);
+      this.executeButton.TabIndex = 1;
+      this.executeButton.Text = "&Execute";
+      this.executeButton.UseVisualStyleBackColor = true;
+      this.executeButton.Click += new System.EventHandler(this.executeButton_Click);
+      // 
+      // tabControl
+      // 
+      this.tabControl.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.tabControl.Controls.Add(this.parametersTabPage);
+      this.tabControl.Controls.Add(this.scopesTabPage);
+      this.tabControl.Location = new System.Drawing.Point(0, 0);
+      this.tabControl.Name = "tabControl";
+      this.tabControl.SelectedIndex = 0;
+      this.tabControl.Size = new System.Drawing.Size(526, 390);
+      this.tabControl.TabIndex = 0;
+      // 
+      // parametersTabPage
+      // 
+      this.parametersTabPage.Controls.Add(this.viewProblemInitializationButton);
+      this.parametersTabPage.Controls.Add(this.setProblemInitializationButton);
+      this.parametersTabPage.Controls.Add(this.problemInitializationTextBox);
+      this.parametersTabPage.Controls.Add(this.setRandomSeedRandomlyCheckBox);
+      this.parametersTabPage.Controls.Add(this.elitesTextBox);
+      this.parametersTabPage.Controls.Add(this.problemInitializationLabel);
+      this.parametersTabPage.Controls.Add(this.elitesLabel);
+      this.parametersTabPage.Controls.Add(this.mutationRateTextBox);
+      this.parametersTabPage.Controls.Add(this.mutationRateLabel);
+      this.parametersTabPage.Controls.Add(this.maximumGenerationsTextBox);
+      this.parametersTabPage.Controls.Add(this.maximumGenerationsLabel);
+      this.parametersTabPage.Controls.Add(this.randomSeedTextBox);
+      this.parametersTabPage.Controls.Add(this.populationSizeTextBox);
+      this.parametersTabPage.Controls.Add(this.setRandomSeedRandomlyLabel);
+      this.parametersTabPage.Controls.Add(this.randomSeedLabel);
+      this.parametersTabPage.Controls.Add(this.populationSizeLabel);
+      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
+      this.parametersTabPage.Name = "parametersTabPage";
+      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.parametersTabPage.Size = new System.Drawing.Size(518, 364);
+      this.parametersTabPage.TabIndex = 0;
+      this.parametersTabPage.Text = "Parameters";
+      this.parametersTabPage.UseVisualStyleBackColor = true;
+      // 
+      // viewProblemInitializationButton
+      // 
+      this.viewProblemInitializationButton.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.viewProblemInitializationButton.Location = new System.Drawing.Point(410, 208);
+      this.viewProblemInitializationButton.Name = "viewProblemInitializationButton";
+      this.viewProblemInitializationButton.Size = new System.Drawing.Size(53, 20);
+      this.viewProblemInitializationButton.TabIndex = 14;
+      this.viewProblemInitializationButton.Text = "View...";
+      this.viewProblemInitializationButton.UseVisualStyleBackColor = true;
+      this.viewProblemInitializationButton.Click += new System.EventHandler(this.viewProblemInjectorButton_Click);
+      // 
+      // setProblemInitializationButton
+      // 
+      this.setProblemInitializationButton.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.setProblemInitializationButton.Location = new System.Drawing.Point(469, 208);
+      this.setProblemInitializationButton.Name = "setProblemInitializationButton";
+      this.setProblemInitializationButton.Size = new System.Drawing.Size(43, 20);
+      this.setProblemInitializationButton.TabIndex = 15;
+      this.setProblemInitializationButton.Text = "Set...";
+      this.setProblemInitializationButton.UseVisualStyleBackColor = true;
+      this.setProblemInitializationButton.Click += new System.EventHandler(this.setProblemInitializationButton_Click);
+      // 
+      // problemInitializationTextBox
+      // 
+      this.problemInitializationTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.problemInitializationTextBox.Location = new System.Drawing.Point(218, 208);
+      this.problemInitializationTextBox.Name = "problemInitializationTextBox";
+      this.problemInitializationTextBox.ReadOnly = true;
+      this.problemInitializationTextBox.Size = new System.Drawing.Size(186, 20);
+      this.problemInitializationTextBox.TabIndex = 13;
+      // 
+      // setRandomSeedRandomlyCheckBox
+      // 
+      this.setRandomSeedRandomlyCheckBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.setRandomSeedRandomlyCheckBox.AutoSize = true;
+      this.setRandomSeedRandomlyCheckBox.Location = new System.Drawing.Point(218, 6);
+      this.setRandomSeedRandomlyCheckBox.Name = "setRandomSeedRandomlyCheckBox";
+      this.setRandomSeedRandomlyCheckBox.Size = new System.Drawing.Size(15, 14);
+      this.setRandomSeedRandomlyCheckBox.TabIndex = 1;
+      this.setRandomSeedRandomlyCheckBox.UseVisualStyleBackColor = true;
+      this.setRandomSeedRandomlyCheckBox.CheckedChanged += new System.EventHandler(this.setRandomSeedRandomlyCheckBox_CheckedChanged);
+      // 
+      // elitesTextBox
+      // 
+      this.elitesTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.elitesTextBox.Location = new System.Drawing.Point(218, 156);
+      this.elitesTextBox.Name = "elitesTextBox";
+      this.elitesTextBox.Size = new System.Drawing.Size(186, 20);
+      this.elitesTextBox.TabIndex = 11;
+      // 
+      // problemInitializationLabel
+      // 
+      this.problemInitializationLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.problemInitializationLabel.AutoSize = true;
+      this.problemInitializationLabel.Location = new System.Drawing.Point(65, 211);
+      this.problemInitializationLabel.Name = "problemInitializationLabel";
+      this.problemInitializationLabel.Size = new System.Drawing.Size(105, 13);
+      this.problemInitializationLabel.TabIndex = 12;
+      this.problemInitializationLabel.Text = "&Problem Initialization:";
+      // 
+      // elitesLabel
+      // 
+      this.elitesLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.elitesLabel.AutoSize = true;
+      this.elitesLabel.Location = new System.Drawing.Point(65, 159);
+      this.elitesLabel.Name = "elitesLabel";
+      this.elitesLabel.Size = new System.Drawing.Size(35, 13);
+      this.elitesLabel.TabIndex = 10;
+      this.elitesLabel.Text = "&Elites:";
+      // 
+      // mutationRateTextBox
+      // 
+      this.mutationRateTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.mutationRateTextBox.Location = new System.Drawing.Point(218, 130);
+      this.mutationRateTextBox.Name = "mutationRateTextBox";
+      this.mutationRateTextBox.Size = new System.Drawing.Size(186, 20);
+      this.mutationRateTextBox.TabIndex = 9;
+      // 
+      // mutationRateLabel
+      // 
+      this.mutationRateLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.mutationRateLabel.AutoSize = true;
+      this.mutationRateLabel.Location = new System.Drawing.Point(65, 133);
+      this.mutationRateLabel.Name = "mutationRateLabel";
+      this.mutationRateLabel.Size = new System.Drawing.Size(77, 13);
+      this.mutationRateLabel.TabIndex = 8;
+      this.mutationRateLabel.Text = "&Mutation Rate:";
+      // 
+      // maximumGenerationsTextBox
+      // 
+      this.maximumGenerationsTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.maximumGenerationsTextBox.Location = new System.Drawing.Point(218, 104);
+      this.maximumGenerationsTextBox.Name = "maximumGenerationsTextBox";
+      this.maximumGenerationsTextBox.Size = new System.Drawing.Size(186, 20);
+      this.maximumGenerationsTextBox.TabIndex = 7;
+      // 
+      // maximumGenerationsLabel
+      // 
+      this.maximumGenerationsLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.maximumGenerationsLabel.AutoSize = true;
+      this.maximumGenerationsLabel.Location = new System.Drawing.Point(65, 107);
+      this.maximumGenerationsLabel.Name = "maximumGenerationsLabel";
+      this.maximumGenerationsLabel.Size = new System.Drawing.Size(114, 13);
+      this.maximumGenerationsLabel.TabIndex = 6;
+      this.maximumGenerationsLabel.Text = "Maximum &Generations:";
+      // 
+      // randomSeedTextBox
+      // 
+      this.randomSeedTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.randomSeedTextBox.Location = new System.Drawing.Point(218, 26);
+      this.randomSeedTextBox.Name = "randomSeedTextBox";
+      this.randomSeedTextBox.Size = new System.Drawing.Size(186, 20);
+      this.randomSeedTextBox.TabIndex = 3;
+      // 
+      // populationSizeTextBox
+      // 
+      this.populationSizeTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.populationSizeTextBox.Location = new System.Drawing.Point(218, 78);
+      this.populationSizeTextBox.Name = "populationSizeTextBox";
+      this.populationSizeTextBox.Size = new System.Drawing.Size(186, 20);
+      this.populationSizeTextBox.TabIndex = 5;
+      // 
+      // setRandomSeedRandomlyLabel
+      // 
+      this.setRandomSeedRandomlyLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.setRandomSeedRandomlyLabel.AutoSize = true;
+      this.setRandomSeedRandomlyLabel.Location = new System.Drawing.Point(65, 6);
+      this.setRandomSeedRandomlyLabel.Name = "setRandomSeedRandomlyLabel";
+      this.setRandomSeedRandomlyLabel.Size = new System.Drawing.Size(147, 13);
+      this.setRandomSeedRandomlyLabel.TabIndex = 0;
+      this.setRandomSeedRandomlyLabel.Text = "Set &Random Seed Randomly:";
+      // 
+      // randomSeedLabel
+      // 
+      this.randomSeedLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.randomSeedLabel.AutoSize = true;
+      this.randomSeedLabel.Location = new System.Drawing.Point(65, 29);
+      this.randomSeedLabel.Name = "randomSeedLabel";
+      this.randomSeedLabel.Size = new System.Drawing.Size(78, 13);
+      this.randomSeedLabel.TabIndex = 2;
+      this.randomSeedLabel.Text = "&Random Seed:";
+      // 
+      // populationSizeLabel
+      // 
+      this.populationSizeLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.populationSizeLabel.AutoSize = true;
+      this.populationSizeLabel.Location = new System.Drawing.Point(65, 81);
+      this.populationSizeLabel.Name = "populationSizeLabel";
+      this.populationSizeLabel.Size = new System.Drawing.Size(83, 13);
+      this.populationSizeLabel.TabIndex = 4;
+      this.populationSizeLabel.Text = "&Population Size:";
+      // 
+      // scopesTabPage
+      // 
+      this.scopesTabPage.Controls.Add(this.scopeView);
+      this.scopesTabPage.Location = new System.Drawing.Point(4, 22);
+      this.scopesTabPage.Name = "scopesTabPage";
+      this.scopesTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.scopesTabPage.Size = new System.Drawing.Size(518, 364);
+      this.scopesTabPage.TabIndex = 2;
+      this.scopesTabPage.Text = "Scopes";
+      this.scopesTabPage.UseVisualStyleBackColor = true;
+      // 
+      // scopeView
+      // 
+      this.scopeView.Caption = "Scope";
+      this.scopeView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.scopeView.Location = new System.Drawing.Point(3, 3);
+      this.scopeView.Name = "scopeView";
+      this.scopeView.Scope = null;
+      this.scopeView.Size = new System.Drawing.Size(512, 358);
+      this.scopeView.TabIndex = 0;
+      // 
+      // abortButton
+      // 
+      this.abortButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.abortButton.Enabled = false;
+      this.abortButton.Location = new System.Drawing.Point(81, 396);
+      this.abortButton.Name = "abortButton";
+      this.abortButton.Size = new System.Drawing.Size(75, 23);
+      this.abortButton.TabIndex = 2;
+      this.abortButton.Text = "&Abort";
+      this.abortButton.UseVisualStyleBackColor = true;
+      this.abortButton.Click += new System.EventHandler(this.abortButton_Click);
+      // 
+      // resetButton
+      // 
+      this.resetButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.resetButton.Location = new System.Drawing.Point(162, 396);
+      this.resetButton.Name = "resetButton";
+      this.resetButton.Size = new System.Drawing.Size(75, 23);
+      this.resetButton.TabIndex = 3;
+      this.resetButton.Text = "&Reset";
+      this.resetButton.UseVisualStyleBackColor = true;
+      this.resetButton.Click += new System.EventHandler(this.resetButton_Click);
+      // 
+      // cloneEngineButton
+      // 
+      this.cloneEngineButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+      this.cloneEngineButton.Location = new System.Drawing.Point(420, 396);
+      this.cloneEngineButton.Name = "cloneEngineButton";
+      this.cloneEngineButton.Size = new System.Drawing.Size(106, 23);
+      this.cloneEngineButton.TabIndex = 4;
+      this.cloneEngineButton.Text = "&Clone Engine...";
+      this.cloneEngineButton.UseVisualStyleBackColor = true;
+      this.cloneEngineButton.Click += new System.EventHandler(this.cloneEngineButton_Click);
+      // 
+      // StandardGpEditor
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.tabControl);
+      this.Controls.Add(this.cloneEngineButton);
+      this.Controls.Add(this.resetButton);
+      this.Controls.Add(this.abortButton);
+      this.Controls.Add(this.executeButton);
+      this.Name = "StandardGpEditor";
+      this.Size = new System.Drawing.Size(526, 419);
+      this.tabControl.ResumeLayout(false);
+      this.parametersTabPage.ResumeLayout(false);
+      this.parametersTabPage.PerformLayout();
+      this.scopesTabPage.ResumeLayout(false);
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.Button executeButton;
+    protected System.Windows.Forms.TabControl tabControl;
+    protected System.Windows.Forms.TabPage parametersTabPage;
+    private System.Windows.Forms.Button abortButton;
+    private System.Windows.Forms.Button resetButton;
+    private System.Windows.Forms.TextBox mutationRateTextBox;
+    private System.Windows.Forms.Label mutationRateLabel;
+    private System.Windows.Forms.TextBox populationSizeTextBox;
+    private System.Windows.Forms.Label populationSizeLabel;
+    private System.Windows.Forms.TabPage scopesTabPage;
+    private System.Windows.Forms.TextBox maximumGenerationsTextBox;
+    private System.Windows.Forms.Label maximumGenerationsLabel;
+    private System.Windows.Forms.TextBox elitesTextBox;
+    private System.Windows.Forms.Label elitesLabel;
+    private System.Windows.Forms.TextBox randomSeedTextBox;
+    private System.Windows.Forms.Label setRandomSeedRandomlyLabel;
+    private System.Windows.Forms.Label randomSeedLabel;
+    private System.Windows.Forms.CheckBox setRandomSeedRandomlyCheckBox;
+    private System.Windows.Forms.Label problemInitializationLabel;
+    private System.Windows.Forms.Button cloneEngineButton;
+    private System.Windows.Forms.TextBox problemInitializationTextBox;
+    private System.Windows.Forms.Button setProblemInitializationButton;
+    private HeuristicLab.Core.ScopeView scopeView;
+    private System.Windows.Forms.Button viewProblemInitializationButton;
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGpEditor.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGpEditor.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGpEditor.cs	(revision 2341)
@@ -0,0 +1,135 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.GP.Algorithms {
+  public partial class StandardGpEditor : EditorBase {
+    private ChooseOperatorDialog chooseOperatorDialog;
+
+    public StandardGP StandardGP {
+      get { return (StandardGP)Item; }
+      set { base.Item = value; }
+    }
+
+    public StandardGpEditor() {
+      InitializeComponent();
+    }
+    public StandardGpEditor(StandardGP sgp)
+      : this() {
+      StandardGP = sgp;
+    }
+
+    protected override void RemoveItemEvents() {
+      StandardGP.Engine.ExceptionOccurred -= new EventHandler<ExceptionEventArgs>(Engine_ExceptionOccurred);
+      StandardGP.Engine.Finished -= new EventHandler(Engine_Finished);
+      scopeView.Scope = null;
+      base.RemoveItemEvents();
+    }
+    protected override void AddItemEvents() {
+      base.AddItemEvents();
+      StandardGP.Engine.ExceptionOccurred += new EventHandler<ExceptionEventArgs>(Engine_ExceptionOccurred);
+      StandardGP.Engine.Finished += new EventHandler(Engine_Finished);
+      SetDataBinding();
+      scopeView.Scope = StandardGP.Engine.GlobalScope;
+    }
+
+    protected override void UpdateControls() {
+      base.UpdateControls();
+      if(StandardGP == null) {
+        tabControl.Enabled = false;
+      } else {
+        tabControl.Enabled = true;
+        problemInitializationTextBox.Text = StandardGP.ProblemInjector.GetType().Name;
+      }
+    }
+
+    protected virtual void SetDataBinding() {
+      setRandomSeedRandomlyCheckBox.DataBindings.Add("Checked", StandardGP, "SetSeedRandomly");
+      randomSeedTextBox.DataBindings.Add("Text", StandardGP, "RandomSeed");
+      populationSizeTextBox.DataBindings.Add("Text", StandardGP, "PopulationSize");
+      maximumGenerationsTextBox.DataBindings.Add("Text", StandardGP, "MaxGenerations");
+      mutationRateTextBox.DataBindings.Add("Text", StandardGP, "MutationRate");
+      elitesTextBox.DataBindings.Add("Text", StandardGP, "Elites");
+    }
+
+    #region Button Events
+    private void viewProblemInjectorButton_Click(object sender, EventArgs e) {
+      IView view = StandardGP.ProblemInjector.CreateView();
+      if(view != null)
+        PluginManager.ControlManager.ShowControl(view);
+    }
+
+    private void setProblemInitializationButton_Click(object sender, EventArgs e) {
+      if (chooseOperatorDialog == null) chooseOperatorDialog = new ChooseOperatorDialog();
+      if (chooseOperatorDialog.ShowDialog(this) == DialogResult.OK) {
+        StandardGP.ProblemInjector = chooseOperatorDialog.Operator;
+        problemInitializationTextBox.Text = StandardGP.ProblemInjector.GetType().Name;
+      }
+    }
+    private void executeButton_Click(object sender, EventArgs e) {
+      executeButton.Enabled = false;
+      abortButton.Enabled = true;
+      resetButton.Enabled = false;
+      StandardGP.Engine.Execute();
+    }
+    private void abortButton_Click(object sender, EventArgs e) {
+      StandardGP.Engine.Abort();
+    }
+    private void resetButton_Click(object sender, EventArgs e) {
+      StandardGP.Engine.Reset();
+    }
+    private void cloneEngineButton_Click(object sender, EventArgs e) {
+      IEngine clone = (IEngine)StandardGP.Engine.Clone();
+      IEditor editor = ((IEditable)clone).CreateEditor();
+      PluginManager.ControlManager.ShowControl(editor);
+    }
+    #endregion
+
+    #region Engine Events
+    private delegate void OnExceptionEventDelegate(object sender, ExceptionEventArgs e);
+    private void Engine_ExceptionOccurred(object sender, ExceptionEventArgs e) {
+      if (InvokeRequired)
+        Invoke(new OnExceptionEventDelegate(Engine_ExceptionOccurred), sender, e);
+      else
+        Auxiliary.ShowErrorMessageBox(e.Exception);
+    }
+    private void Engine_Finished(object sender, EventArgs e) {
+      if(InvokeRequired)
+        Invoke((EventHandler)Engine_Finished, sender, e);
+      else {
+        scopeView.Refresh();
+        executeButton.Enabled = true;
+        abortButton.Enabled = false;
+        resetButton.Enabled = true;
+      }
+    }
+    #endregion
+
+    private void setRandomSeedRandomlyCheckBox_CheckedChanged(object sender, EventArgs e) {
+      randomSeedTextBox.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
+      randomSeedLabel.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGpEditor.resx
===================================================================
--- /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGpEditor.resx	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.Algorithms/3.2/StandardGpEditor.resx	(revision 2341)
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/DefaultClassificationAlgorithmOperators.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/DefaultClassificationAlgorithmOperators.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/DefaultClassificationAlgorithmOperators.cs	(revision 2341)
@@ -0,0 +1,95 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.DataAnalysis;
+using HeuristicLab.GP.Interfaces;
+using HeuristicLab.Operators;
+using HeuristicLab.Modeling;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.GP.StructureIdentification.Classification {
+  internal static class DefaultClassificationAlgorithmOperators {
+    internal static IOperator CreatePostProcessingOperator() {
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator());
+
+      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
+      SequentialProcessor individualProc = new SequentialProcessor();
+      subScopesProc.AddSubOperator(individualProc);
+      seq.AddSubOperator(subScopesProc);
+      AccuracyEvaluator trainingAccuracy = new AccuracyEvaluator();
+      trainingAccuracy.Name = "TrainingAccuracyEvaluator";
+      trainingAccuracy.GetVariableInfo("Accuracy").ActualName = "TrainingAccuracy";
+      trainingAccuracy.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingAccuracy.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+
+      AccuracyEvaluator validationAccuracy = new AccuracyEvaluator();
+      validationAccuracy.Name = "ValidationAccuracyEvaluator";
+      validationAccuracy.GetVariableInfo("Accuracy").ActualName = "ValidationAccuracy";
+      validationAccuracy.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationAccuracy.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+
+      AccuracyEvaluator testAccuracy = new AccuracyEvaluator();
+      testAccuracy.Name = "TestAccuracyEvaluator";
+      testAccuracy.GetVariableInfo("Accuracy").ActualName = "TestAccuracy";
+      testAccuracy.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testAccuracy.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+
+      ConfusionMatrixEvaluator trainingConfusionMatrix = new ConfusionMatrixEvaluator();
+      trainingConfusionMatrix.Name = "TrainingConfusionMatrixEvaluator";
+      trainingConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "TrainingConfusionMatrix";
+      trainingConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+
+      ConfusionMatrixEvaluator validationConfusionMatrix = new ConfusionMatrixEvaluator();
+      validationConfusionMatrix.Name = "ValidationConfusionMatrixEvaluator";
+      validationConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "ValidationConfusionMatrix";
+      validationConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+
+      ConfusionMatrixEvaluator testConfusionMatrix = new ConfusionMatrixEvaluator();
+      testConfusionMatrix.Name = "TestConfusionMatrixEvaluator";
+      testConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "TestConfusionMatrix";
+      testConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+
+      individualProc.AddSubOperator(trainingAccuracy);
+      individualProc.AddSubOperator(validationAccuracy);
+      individualProc.AddSubOperator(testAccuracy);
+      individualProc.AddSubOperator(trainingConfusionMatrix);
+      individualProc.AddSubOperator(validationConfusionMatrix);
+      individualProc.AddSubOperator(testConfusionMatrix);
+      return seq;
+    }
+
+    internal static IOperator CreateProblemInjector() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "ProblemInjector";
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(new ProblemInjector());
+      seq.AddSubOperator(new TargetClassesCalculator());
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLab.GP.StructureIdentification.Classification-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLab.GP.StructureIdentification.Classification-3.3.csproj	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLab.GP.StructureIdentification.Classification-3.3.csproj	(revision 2341)
@@ -83,4 +83,6 @@
     <Compile Include="ClassificationMeanSquaredErrorEvaluator.cs" />
     <Compile Include="ConfusionMatrixEvaluator.cs" />
+    <Compile Include="TargetClassesCalculator.cs" />
+    <Compile Include="DefaultClassificationAlgorithmOperators.cs" />
     <Compile Include="GPClassificationEvaluatorBase.cs" />
     <Compile Include="CrossValidation.cs" />
@@ -109,4 +111,8 @@
       <Project>{F473D9AF-3F09-4296-9F28-3C65118DAFFA}</Project>
       <Name>HeuristicLab.Data-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.GP.Algorithms\3.2\HeuristicLab.GP.Algorithms-3.2.csproj">
+      <Project>{3127719F-110E-4558-8845-98559DBB422D}</Project>
+      <Name>HeuristicLab.GP.Algorithms-3.2</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.GP.Interfaces\3.3\HeuristicLab.GP.Interfaces-3.3.csproj">
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/OffspringSelectionGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/OffspringSelectionGP.cs	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/OffspringSelectionGP.cs	(revision 2341)
@@ -27,9 +27,10 @@
   public class OffspringSelectionGP : HeuristicLab.GP.StructureIdentification.OffspringSelectionGP, IClassificationAlgorithm {
 
-    protected override IOperator CreateBestSolutionProcessor() {
-      IOperator seq = new SequentialProcessor();
-      seq.AddSubOperator(base.CreateBestSolutionProcessor());
-      seq.AddSubOperator(StandardGP.BestSolutionProcessor);
-      return seq;
+    protected override IOperator CreateProblemInjector() {
+      return DefaultClassificationAlgorithmOperators.CreateProblemInjector();
+    }
+
+    protected override IOperator CreatePostProcessingOperator() {
+      return DefaultClassificationAlgorithmOperators.CreatePostProcessingOperator();
     }
   }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/StandardGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/StandardGP.cs	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/StandardGP.cs	(revision 2341)
@@ -23,54 +23,10 @@
 using HeuristicLab.Modeling;
 using HeuristicLab.Operators;
+using System;
 
 namespace HeuristicLab.GP.StructureIdentification.Classification {
   public class StandardGP : HeuristicLab.GP.StructureIdentification.StandardGP, IClassificationAlgorithm {
-    protected override IOperator CreateBestSolutionProcessor() {
-      IOperator bestSolutionProcessor = BestSolutionProcessor;
-      bestSolutionProcessor.AddSubOperator(base.CreateBestSolutionProcessor());
-      return bestSolutionProcessor;
-    }
-
-    internal static IOperator BestSolutionProcessor {
-      get {
-        SequentialProcessor seq = new SequentialProcessor();
-        AccuracyEvaluator trainingAccuracy = new AccuracyEvaluator();
-        trainingAccuracy.GetVariableInfo("Accuracy").ActualName = "TrainingAccuracy";
-        trainingAccuracy.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-        trainingAccuracy.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-
-        AccuracyEvaluator validationAccuracy = new AccuracyEvaluator();
-        validationAccuracy.GetVariableInfo("Accuracy").ActualName = "ValidationAccuracy";
-        validationAccuracy.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-        validationAccuracy.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-
-        AccuracyEvaluator testAccuracy = new AccuracyEvaluator();
-        testAccuracy.GetVariableInfo("Accuracy").ActualName = "TestAccuracy";
-        testAccuracy.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-        testAccuracy.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-
-        ConfusionMatrixEvaluator trainingConfusionMatrix = new ConfusionMatrixEvaluator();
-        trainingConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "TrainingConfusionMatrix";
-        trainingConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-        trainingConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-
-        ConfusionMatrixEvaluator validationConfusionMatrix = new ConfusionMatrixEvaluator();
-        validationConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "ValidationConfusionMatrix";
-        validationConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-        validationConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-
-        ConfusionMatrixEvaluator testConfusionMatrix = new ConfusionMatrixEvaluator();
-        testConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "TestConfusionMatrix";
-        testConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-        testConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-
-        seq.AddSubOperator(trainingAccuracy);
-        seq.AddSubOperator(validationAccuracy);
-        seq.AddSubOperator(testAccuracy);
-        seq.AddSubOperator(trainingConfusionMatrix);
-        seq.AddSubOperator(validationConfusionMatrix);
-        seq.AddSubOperator(testConfusionMatrix);
-        return seq;
-      }
+    protected override IOperator CreatePostProcessingOperator() {
+      return DefaultClassificationAlgorithmOperators.CreatePostProcessingOperator();
     }
   }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/TargetClassesCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/TargetClassesCalculator.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/TargetClassesCalculator.cs	(revision 2341)
@@ -0,0 +1,51 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.DataAnalysis;
+using System.Linq;
+
+namespace HeuristicLab.GP.StructureIdentification.Classification {
+  public class TargetClassesCalculator : OperatorBase {
+
+    public TargetClassesCalculator()
+      : base() {
+      AddVariableInfo(new VariableInfo("Dataset", "The dataset", typeof(Dataset), VariableKind.In));
+      AddVariableInfo(new VariableInfo("TargetVariable", "Index of the target variable", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("TargetClassValues", "The original class values of target variable (for instance negative=0 and positive=1).", typeof(ItemList<DoubleData>), VariableKind.New));
+    }
+
+    public override IOperation Apply(IScope scope) {
+      Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
+      int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
+
+      ItemList<DoubleData> classes = new ItemList<DoubleData>();
+      foreach(double x in dataset.GetVariableValues(targetVariable).Distinct().OrderBy(v=>v)) {
+        classes.Add(new DoubleData(x));
+      }
+
+      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TargetClassValues"), classes));
+      return null;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/DefaultTimeSeriesOperators.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/DefaultTimeSeriesOperators.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/DefaultTimeSeriesOperators.cs	(revision 2341)
@@ -0,0 +1,97 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.DataAnalysis;
+using HeuristicLab.GP.Interfaces;
+using HeuristicLab.Operators;
+using HeuristicLab.Modeling;
+using HeuristicLab.Logging;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
+  internal static class DefaultTimeSeriesOperators {
+    internal static IOperator CreateFunctionLibraryInjector() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "FunctionLibraryInjector";
+      SequentialProcessor seq = new SequentialProcessor();
+      FunctionLibraryInjector funLibInjector = new FunctionLibraryInjector();
+      funLibInjector.GetVariable("Differentials").Value = new BoolData(true);
+      seq.AddSubOperator(funLibInjector);
+      seq.AddSubOperator(new HL3TreeEvaluatorInjector());
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    internal static IOperator CreateProblemInjector() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "ProblemInjector";
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(new ProblemInjector());
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    internal static IOperator CreatePostProcessingOperator() {
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator());
+
+      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
+      SequentialProcessor individualProc = new SequentialProcessor();
+      subScopesProc.AddSubOperator(individualProc);
+      seq.AddSubOperator(subScopesProc);
+
+      TheilInequalityCoefficientEvaluator trainingTheil = new TheilInequalityCoefficientEvaluator();
+      trainingTheil.Name = "TrainingTheilInequalityEvaluator";
+      trainingTheil.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingTheil.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      trainingTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TrainingTheilInequalityCoefficient";
+      trainingTheil.GetVariableInfo("TheilInequalityCoefficientBias").ActualName = "TrainingTheilInequalityCoefficientBias";
+      trainingTheil.GetVariableInfo("TheilInequalityCoefficientVariance").ActualName = "TrainingTheilInequalityCoefficientVariance";
+      trainingTheil.GetVariableInfo("TheilInequalityCoefficientCovariance").ActualName = "TrainingTheilInequalityCoefficientCovariance";
+
+      TheilInequalityCoefficientEvaluator validationTheil = new TheilInequalityCoefficientEvaluator();
+      validationTheil.Name = "ValidationTheilInequalityEvaluator";
+      validationTheil.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationTheil.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      validationTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "ValidationTheilInequalityCoefficient";
+      validationTheil.GetVariableInfo("TheilInequalityCoefficientBias").ActualName = "ValidationTheilInequalityCoefficientBias";
+      validationTheil.GetVariableInfo("TheilInequalityCoefficientVariance").ActualName = "ValidationTheilInequalityCoefficientVariance";
+      validationTheil.GetVariableInfo("TheilInequalityCoefficientCovariance").ActualName = "ValidationTheilInequalityCoefficientCovariance";
+
+      TheilInequalityCoefficientEvaluator testTheil = new TheilInequalityCoefficientEvaluator();
+      testTheil.Name = "TestTheilInequalityEvaluator";
+      testTheil.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testTheil.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      testTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TestTheilInequalityCoefficient";
+      testTheil.GetVariableInfo("TheilInequalityCoefficientBias").ActualName = "TestTheilInequalityCoefficientBias";
+      testTheil.GetVariableInfo("TheilInequalityCoefficientVariance").ActualName = "TestTheilInequalityCoefficientVariance";
+      testTheil.GetVariableInfo("TheilInequalityCoefficientCovariance").ActualName = "TestTheilInequalityCoefficientCovariance";
+
+      individualProc.AddSubOperator(trainingTheil);
+      individualProc.AddSubOperator(validationTheil);
+      individualProc.AddSubOperator(testTheil);
+      return seq;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/HeuristicLab.GP.StructureIdentification.TimeSeries-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/HeuristicLab.GP.StructureIdentification.TimeSeries-3.3.csproj	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/HeuristicLab.GP.StructureIdentification.TimeSeries-3.3.csproj	(revision 2341)
@@ -83,4 +83,5 @@
   <ItemGroup>
     <Compile Include="AveragePercentageChangeEvaluator.cs" />
+    <Compile Include="DefaultTimeSeriesOperators.cs" />
     <Compile Include="HeuristicLabGPTimeSeriesPlugin.cs" />
     <Compile Include="OffspringSelectionGP.cs" />
@@ -102,4 +103,8 @@
       <Project>{F473D9AF-3F09-4296-9F28-3C65118DAFFA}</Project>
       <Name>HeuristicLab.Data-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.GP.Algorithms\3.2\HeuristicLab.GP.Algorithms-3.2.csproj">
+      <Project>{3127719F-110E-4558-8845-98559DBB422D}</Project>
+      <Name>HeuristicLab.GP.Algorithms-3.2</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.GP.Interfaces\3.3\HeuristicLab.GP.Interfaces-3.3.csproj">
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/OffspringSelectionGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/OffspringSelectionGP.cs	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/OffspringSelectionGP.cs	(revision 2341)
@@ -23,42 +23,46 @@
 using HeuristicLab.Modeling;
 using HeuristicLab.Operators;
+using System;
+using HeuristicLab.Data;
+using HeuristicLab.GP.Algorithms;
 
 namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
   public class OffspringSelectionGP : HeuristicLab.GP.StructureIdentification.OffspringSelectionGP, ITimeSeriesAlgorithm {
-    public override IOperator ProblemInjector {
-      get {
-        CombinedOperator algo = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-        return algo.OperatorGraph.InitialOperator.SubOperators[1];
-      }
-      set {
-        CombinedOperator algo = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-        algo.OperatorGraph.InitialOperator.RemoveSubOperator(1);
-        value.Name = "ProblemInjector";
-        algo.OperatorGraph.InitialOperator.AddSubOperator(value, 1);
-      }
+
+    public int MinTimeOffset {
+      get { return GetVariableInjector().GetVariable("MinTimeOffset").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MinTimeOffset").GetValue<IntData>().Data = value; }
+    }
+
+    public int MaxTimeOffset {
+      get { return GetVariableInjector().GetVariable("MaxTimeOffset").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxTimeOffset").GetValue<IntData>().Data = value; }
+    }
+
+    public bool UseEstimatedTargetValue {
+      get { return GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data; }
+      set { GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data = value; }
+    }
+
+    protected override IOperator CreateProblemInjector() {
+      return DefaultTimeSeriesOperators.CreateProblemInjector();
     }
 
     protected override IOperator CreateFunctionLibraryInjector() {
-      return new FunctionLibraryInjector();
+      return DefaultTimeSeriesOperators.CreateFunctionLibraryInjector();
     }
 
-    protected override IOperator CreateProblemInjector() {
-      return new ProblemInjector();
+    protected override IOperator CreatePostProcessingOperator() {
+      return DefaultTimeSeriesOperators.CreatePostProcessingOperator();
     }
 
-    protected override IOperator CreateBestSolutionProcessor() {
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(base.CreateBestSolutionProcessor());
-      seq.AddSubOperator(StandardGP.BestSolutionProcessor);
-      return seq;
+    protected override VariableInjector CreateGlobalInjector() {
+      VariableInjector injector = base.CreateGlobalInjector();
+      injector.AddVariable(new HeuristicLab.Core.Variable("MinTimeOffset", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTimeOffset", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
+      return injector;
     }
 
-    public override IEditor CreateEditor() {
-      return new OffspringSelectionGpEditor(this);
-    }
-
-    public override IView CreateView() {
-      return new OffspringSelectionGpEditor(this);
-    }
   }
 }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/StandardGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/StandardGP.cs	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/StandardGP.cs	(revision 2341)
@@ -25,112 +25,41 @@
 using HeuristicLab.Modeling;
 using HeuristicLab.Operators;
+using System;
 
 namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
   public class StandardGP : HeuristicLab.GP.StructureIdentification.StandardGP, ITimeSeriesAlgorithm {
-    public override IOperator ProblemInjector {
-      get {
-        CombinedOperator algo = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-        return algo.OperatorGraph.InitialOperator.SubOperators[1];
-      }
-      set {
-        CombinedOperator algo = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-        algo.OperatorGraph.InitialOperator.RemoveSubOperator(1);
-        value.Name = "ProblemInjector";
-        algo.OperatorGraph.InitialOperator.AddSubOperator(value, 1);
-      }
+    public int MinTimeOffset {
+      get { return GetVariableInjector().GetVariable("MinTimeOffset").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MinTimeOffset").GetValue<IntData>().Data = value; }
     }
-    
-    protected override IOperator CreateFunctionLibraryInjector() {
-      return new FunctionLibraryInjector();
+
+    public int MaxTimeOffset {
+      get { return GetVariableInjector().GetVariable("MaxTimeOffset").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxTimeOffset").GetValue<IntData>().Data = value; }
+    }
+
+    public bool UseEstimatedTargetValue {
+      get { return GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data; }
+      set { GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data = value; }
     }
 
     protected override IOperator CreateProblemInjector() {
-      return new ProblemInjector();
+      return DefaultTimeSeriesOperators.CreateProblemInjector();
     }
 
-    protected override IOperator CreateBestSolutionProcessor() {
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(base.CreateBestSolutionProcessor());
-      seq.AddSubOperator(BestSolutionProcessor);
-      return seq;
+    protected override IOperator CreateFunctionLibraryInjector() {
+      return DefaultTimeSeriesOperators.CreateFunctionLibraryInjector();
     }
 
-    public override IEditor CreateEditor() {
-      return new StandardGpEditor(this);
+    protected override IOperator CreatePostProcessingOperator() {
+      return DefaultTimeSeriesOperators.CreatePostProcessingOperator();
     }
 
-    public override IView CreateView() {
-      return new StandardGpEditor(this);
-    }
-
-    internal static IOperator BestSolutionProcessor {
-      get {
-        SequentialProcessor seq = new SequentialProcessor();
-        TheilInequalityCoefficientEvaluator trainingTheil = new TheilInequalityCoefficientEvaluator();
-        trainingTheil.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-        trainingTheil.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-        trainingTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TrainingTheilInequalityCoefficient";
-        trainingTheil.GetVariableInfo("TheilInequalityCoefficientBias").ActualName = "TrainingTheilInequalityCoefficientBias";
-        trainingTheil.GetVariableInfo("TheilInequalityCoefficientVariance").ActualName = "TrainingTheilInequalityCoefficientVariance";
-        trainingTheil.GetVariableInfo("TheilInequalityCoefficientCovariance").ActualName = "TrainingTheilInequalityCoefficientCovariance";
-
-        TheilInequalityCoefficientEvaluator validationTheil = new TheilInequalityCoefficientEvaluator();
-        validationTheil.GetVariableInfo("SamplesStart").ActualName = "ActualValidationSamplesStart";
-        validationTheil.GetVariableInfo("SamplesEnd").ActualName = "ActualValidationSamplesEnd";
-        validationTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "ValidationTheilInequalityCoefficient";
-        validationTheil.GetVariableInfo("TheilInequalityCoefficientBias").ActualName = "ValidationTheilInequalityCoefficientBias";
-        validationTheil.GetVariableInfo("TheilInequalityCoefficientVariance").ActualName = "ValidationTheilInequalityCoefficientVariance";
-        validationTheil.GetVariableInfo("TheilInequalityCoefficientCovariance").ActualName = "ValidationTheilInequalityCoefficientCovariance";
-
-        TheilInequalityCoefficientEvaluator testTheil = new TheilInequalityCoefficientEvaluator();
-        testTheil.GetVariableInfo("SamplesStart").ActualName = "ActualTestSamplesStart";
-        testTheil.GetVariableInfo("SamplesEnd").ActualName = "ActualTestSamplesEnd";
-        testTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TestTheilInequalityCoefficient";
-        testTheil.GetVariableInfo("TheilInequalityCoefficientBias").ActualName = "TestTheilInequalityCoefficientBias";
-        testTheil.GetVariableInfo("TheilInequalityCoefficientVariance").ActualName = "TestTheilInequalityCoefficientVariance";
-        testTheil.GetVariableInfo("TheilInequalityCoefficientCovariance").ActualName = "TestTheilInequalityCoefficientCovariance";
-
-        SimpleEvaluator trainingEvaluator = new SimpleEvaluator();
-        trainingEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-        trainingEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-        trainingEvaluator.GetVariableInfo("Values").ActualName = "PredictedValuesTraining";
-
-        SimpleEvaluator validationEvaluator = new SimpleEvaluator();
-        validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-        validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-        validationEvaluator.GetVariableInfo("Values").ActualName = "PredictedValuesValidation";
-
-        SimpleEvaluator testEvaluator = new SimpleEvaluator();
-        testEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-        testEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-        testEvaluator.GetVariableInfo("Values").ActualName = "PredictedValuesTest";
-
-        LinechartInjector trainingChartInjector = new LinechartInjector();
-        trainingChartInjector.GetVariableValue<IntData>("NumberOfLines", null, false).Data = 2;
-        trainingChartInjector.GetVariableInfo("Values").ActualName = "PredictedValuesTraining";
-        trainingChartInjector.GetVariableInfo("Linechart").ActualName = "LinechartTrainingPredictedValues";
-
-        LinechartInjector validationChartInjector = new LinechartInjector();
-        validationChartInjector.GetVariableValue<IntData>("NumberOfLines", null, false).Data = 2;
-        validationChartInjector.GetVariableInfo("Values").ActualName = "PredictedValuesValidation";
-        validationChartInjector.GetVariableInfo("Linechart").ActualName = "LinechartValidationPredictedValues";
-
-        LinechartInjector testChartInjector = new LinechartInjector();
-        testChartInjector.GetVariableValue<IntData>("NumberOfLines", null, false).Data = 2;
-        testChartInjector.GetVariableInfo("Values").ActualName = "PredictedValuesTest";
-        testChartInjector.GetVariableInfo("Linechart").ActualName = "LinechartTestPredictedValues";
-
-        seq.AddSubOperator(trainingTheil);
-        seq.AddSubOperator(validationTheil);
-        seq.AddSubOperator(testTheil);
-        seq.AddSubOperator(trainingEvaluator);
-        seq.AddSubOperator(trainingChartInjector);
-        seq.AddSubOperator(validationEvaluator);
-        seq.AddSubOperator(validationChartInjector);
-        seq.AddSubOperator(testEvaluator);
-        seq.AddSubOperator(testChartInjector);
-
-        return seq;
-      }
+    protected override VariableInjector CreateGlobalInjector() {
+      VariableInjector injector = base.CreateGlobalInjector();
+      injector.AddVariable(new HeuristicLab.Core.Variable("MinTimeOffset", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTimeOffset", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
+      return injector;
     }
   }
Index: unk/sources/HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/AlgorithmBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/AlgorithmBase.cs	(revision 2340)
+++ 	(revision )
@@ -1,666 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.Xml;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.DataAnalysis;
-using HeuristicLab.Evolutionary;
-using HeuristicLab.GP.Interfaces;
-using HeuristicLab.Logging;
-using HeuristicLab.Modeling;
-using HeuristicLab.Operators;
-using HeuristicLab.Random;
-using HeuristicLab.Selection;
-using HeuristicLab.Operators.Programmable;
-
-namespace HeuristicLab.GP.StructureIdentification {
-  public abstract class AlgorithmBase : ItemBase, IAlgorithm, IStochasticAlgorithm {
-    public virtual string Name { get { return "GP"; } }
-    public virtual string Description { get { return "TODO"; } }
-
-    public abstract Dataset Dataset { get; set; }
-    public abstract int TargetVariable { get; set; }
-
-    public virtual double MutationRate {
-      get { return GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data; }
-      set { GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data = value; }
-    }
-    public virtual int PopulationSize {
-      get { return GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data = value; }
-    }
-
-    public virtual bool SetSeedRandomly {
-      get { return GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data; }
-      set { GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data = value; }
-    }
-
-    public virtual int RandomSeed {
-      get { return GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data; }
-      set { GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data = value; }
-    }
-
-    public virtual IOperator ProblemInjector {
-      get { return algorithm.SubOperators[1]; }
-      set {
-        value.Name = "ProblemInjector";
-        algorithm.RemoveSubOperator(1);
-        algorithm.AddSubOperator(value, 1);
-      }
-    }
-
-    private IAnalyzerModel model;
-    public virtual IAnalyzerModel Model {
-      get {
-        if (!engine.Terminated) throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
-        if (model == null) {
-          IScope bestModelScope = engine.GlobalScope.SubScopes[0];
-          model = CreateGPModel(bestModelScope);
-        }
-        return model;
-      }
-    }
-
-    public virtual int Elites {
-      get { return GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data = value; }
-    }
-
-    public virtual int MaxTreeSize {
-      get { return GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data = value; }
-    }
-
-    public virtual int MaxTreeHeight {
-      get { return GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data = value; }
-    }
-
-    public virtual int Parents {
-      get { return GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data = value; }
-    }
-
-    public virtual bool UseEstimatedTargetValue {
-      get { return GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data; }
-      set { GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data = value; }
-    }
-
-    private IOperator algorithm;
-
-    private SequentialEngine.SequentialEngine engine;
-    public IEngine Engine {
-      get { return engine; }
-      protected set { engine = (SequentialEngine.SequentialEngine)value; }
-    }
-
-    public AlgorithmBase() {
-      engine = new SequentialEngine.SequentialEngine();
-      CombinedOperator algo = CreateAlgorithm();
-      engine.OperatorGraph.AddOperator(algo);
-      engine.OperatorGraph.InitialOperator = algo;
-      SetSeedRandomly = true;
-      Elites = 1;
-      MutationRate = 0.15;
-      PopulationSize = 1000;
-      MaxTreeSize = 100;
-      MaxTreeHeight = 10;
-      Parents = 2000;
-      UseEstimatedTargetValue = false;
-    }
-
-    protected internal virtual CombinedOperator CreateAlgorithm() {
-      CombinedOperator algo = new CombinedOperator();
-      algo.Name = "GP";
-      SequentialProcessor seq = new SequentialProcessor();
-      IOperator problemInjector = CreateProblemInjector();
-
-      RandomInjector randomInjector = new RandomInjector();
-      randomInjector.Name = "Random Injector";
-
-      IOperator globalInjector = CreateGlobalInjector();
-      IOperator treeEvaluatorInjector = new HL2TreeEvaluatorInjector();
-      IOperator initialization = CreateInitialization();
-      IOperator funLibInjector = CreateFunctionLibraryInjector();
-
-      IOperator mainLoop = CreateMainLoop();
-      mainLoop.Name = "Main loop";
-
-      IOperator treeCreator = CreateTreeCreator();
-
-      MeanSquaredErrorEvaluator evaluator = new MeanSquaredErrorEvaluator();
-      evaluator.GetVariableInfo("MSE").ActualName = "Quality";
-      evaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      evaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      evaluator.Name = "Evaluator";
-
-      IOperator crossover = CreateCrossover();
-      IOperator manipulator = CreateManipulator();
-
-      IOperator selector = CreateSelector();
-      LeftReducer cleanUp = new LeftReducer();
-
-      seq.AddSubOperator(randomInjector);
-      seq.AddSubOperator(problemInjector);
-      seq.AddSubOperator(globalInjector);
-      seq.AddSubOperator(treeEvaluatorInjector);
-      seq.AddSubOperator(funLibInjector);
-      seq.AddSubOperator(initialization);
-      seq.AddSubOperator(mainLoop);
-      seq.AddSubOperator(cleanUp);
-      seq.AddSubOperator(CreateModelAnalysisOperator());
-
-      initialization.AddSubOperator(treeCreator);
-      initialization.AddSubOperator(evaluator);
-
-      mainLoop.AddSubOperator(selector);
-      mainLoop.AddSubOperator(crossover);
-      mainLoop.AddSubOperator(manipulator);
-      mainLoop.AddSubOperator(evaluator);
-      algo.OperatorGraph.AddOperator(seq);
-      algo.OperatorGraph.InitialOperator = seq;
-      this.algorithm = seq;
-      return algo;
-    }
-
-    protected internal virtual IOperator CreateModelAnalysisOperator() {
-      CombinedOperator op = new CombinedOperator();
-      SequentialProcessor seq = new SequentialProcessor();
-      SolutionExtractor extractor = new SolutionExtractor();
-      extractor.GetVariableInfo("Scope").ActualName = "BestValidationSolution";
-      SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
-      SequentialProcessor solutionProc = new SequentialProcessor();
-
-      seq.AddSubOperator(extractor);
-      seq.AddSubOperator(seqSubScopeProc);
-      seqSubScopeProc.AddSubOperator(solutionProc);
-
-      HL2TreeEvaluatorInjector evaluatorInjector = new HL2TreeEvaluatorInjector();
-      evaluatorInjector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
-      evaluatorInjector.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-
-      #region MSE
-      MeanSquaredErrorEvaluator trainingMseEvaluator = new MeanSquaredErrorEvaluator();
-      trainingMseEvaluator.Name = "TrainingMseEvaluator";
-      trainingMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      trainingMseEvaluator.GetVariableInfo("MSE").ActualName = "TrainingMSE";
-      trainingMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      MeanSquaredErrorEvaluator validationMseEvaluator = new MeanSquaredErrorEvaluator();
-      validationMseEvaluator.Name = "ValidationMseEvaluator";
-      validationMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      validationMseEvaluator.GetVariableInfo("MSE").ActualName = "ValidationMSE";
-      validationMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
-      testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
-      testMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestMSE";
-      testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion
-      #region MAPE
-      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
-      trainingMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
-      trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      validationMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
-      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
-      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      testMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      testMapeEvaluator.Name = "TestMapeEvaluator";
-      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
-      testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion
-      #region MAPRE
-      MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
-      trainingMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
-      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
-      trainingMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      trainingMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      MeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
-      validationMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
-      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
-      validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
-      testMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      testMapreEvaluator.Name = "TestMapreEvaluator";
-      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
-      testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion MAPRE
-      #region R2
-      CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
-      trainingR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      trainingR2Evaluator.Name = "TrainingR2Evaluator";
-      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
-      trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
-      validationR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      validationR2Evaluator.Name = "ValidationR2Evaluator";
-      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
-      validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
-      testR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      testR2Evaluator.Name = "TestR2Evaluator";
-      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
-      testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion
-      #region VAF
-      VarianceAccountedForEvaluator trainingVAFEvaluator = new VarianceAccountedForEvaluator();
-      trainingVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
-      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
-      trainingVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      trainingVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      VarianceAccountedForEvaluator validationVAFEvaluator = new VarianceAccountedForEvaluator();
-      validationVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
-      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
-      validationVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      VarianceAccountedForEvaluator testVAFEvaluator = new VarianceAccountedForEvaluator();
-      testVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      testVAFEvaluator.Name = "TestVAFEvaluator";
-      testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
-      testVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion
-
-      solutionProc.AddSubOperator(evaluatorInjector);
-      solutionProc.AddSubOperator(trainingMseEvaluator);
-      solutionProc.AddSubOperator(validationMseEvaluator);
-      solutionProc.AddSubOperator(testMseEvaluator);
-      solutionProc.AddSubOperator(trainingMapeEvaluator);
-      solutionProc.AddSubOperator(validationMapeEvaluator);
-      solutionProc.AddSubOperator(testMapeEvaluator);
-      solutionProc.AddSubOperator(trainingMapreEvaluator);
-      solutionProc.AddSubOperator(validationMapreEvaluator);
-      solutionProc.AddSubOperator(testMapreEvaluator);
-      solutionProc.AddSubOperator(trainingR2Evaluator);
-      solutionProc.AddSubOperator(validationR2Evaluator);
-      solutionProc.AddSubOperator(testR2Evaluator);
-      solutionProc.AddSubOperator(trainingVAFEvaluator);
-      solutionProc.AddSubOperator(validationVAFEvaluator);
-      solutionProc.AddSubOperator(testVAFEvaluator);
-
-      #region variable impacts
-      // calculate and set variable impacts
-      VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
-      namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
-      PredictorBuilder predictorBuilder = new PredictorBuilder();
-      predictorBuilder.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      predictorBuilder.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
-
-      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
-      evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      evaluationImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
-      qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-
-      solutionProc.AddSubOperator(namesExtractor);
-      solutionProc.AddSubOperator(predictorBuilder);
-      solutionProc.AddSubOperator(evaluationImpactCalculator);
-      solutionProc.AddSubOperator(qualityImpactCalculator);
-      #endregion
-
-      op.OperatorGraph.AddOperator(seq);
-      op.OperatorGraph.InitialOperator = seq;
-      return op;
-    }
-
-    protected internal virtual IOperator CreateProblemInjector() {
-      return new EmptyOperator();
-    }
-
-    protected internal abstract IOperator CreateSelector();
-
-    protected internal abstract IOperator CreateCrossover();
-
-    protected internal abstract IOperator CreateTreeCreator();
-
-    protected internal abstract IOperator CreateFunctionLibraryInjector();
-
-    protected internal virtual IOperator CreateGlobalInjector() {
-      VariableInjector injector = new VariableInjector();
-      injector.Name = "Global Injector";
-      injector.AddVariable(new HeuristicLab.Core.Variable("Generations", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", new DoubleData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", new IntData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", new IntData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Maximization", new BoolData(false)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", new IntData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", new IntData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("EvaluatedSolutions", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", new IntData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(10.0)));
-      return injector;
-    }
-
-    protected internal abstract IOperator CreateManipulator();
-
-    protected internal virtual IOperator CreateInitialization() {
-      CombinedOperator init = new CombinedOperator();
-      init.Name = "Initialization";
-      SequentialProcessor seq = new SequentialProcessor();
-      SubScopesCreater subScopesCreater = new SubScopesCreater();
-      subScopesCreater.GetVariableInfo("SubScopes").ActualName = "PopulationSize";
-      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
-      SequentialProcessor individualSeq = new SequentialProcessor();
-      OperatorExtractor treeCreater = new OperatorExtractor();
-      treeCreater.Name = "Tree generator (extr.)";
-      treeCreater.GetVariableInfo("Operator").ActualName = "Tree generator";
-      OperatorExtractor evaluator = new OperatorExtractor();
-      evaluator.Name = "Evaluator (extr.)";
-      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
-      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
-      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
-      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      Counter evalCounter = new Counter();
-      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
-      Sorter sorter = new Sorter();
-      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
-      sorter.GetVariableInfo("Value").ActualName = "Quality";
-
-      seq.AddSubOperator(subScopesCreater);
-      seq.AddSubOperator(subScopesProc);
-      seq.AddSubOperator(sorter);
-
-      subScopesProc.AddSubOperator(individualSeq);
-      individualSeq.AddSubOperator(treeCreater);
-      individualSeq.AddSubOperator(evaluator);
-      individualSeq.AddSubOperator(validationEvaluator);
-      individualSeq.AddSubOperator(evalCounter);
-
-      init.OperatorGraph.AddOperator(seq);
-      init.OperatorGraph.InitialOperator = seq;
-      return init;
-    }
-
-    protected internal virtual IOperator CreateMainLoop() {
-      CombinedOperator main = new CombinedOperator();
-      SequentialProcessor seq = new SequentialProcessor();
-      IOperator childCreater = CreateChildCreater();
-      IOperator replacement = CreateReplacement();
-
-      BestSolutionStorer solutionStorer = new BestSolutionStorer();
-      solutionStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
-      solutionStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
-      solutionStorer.AddSubOperator(CreateBestSolutionProcessor());
-
-      BestAverageWorstQualityCalculator qualityCalculator = new BestAverageWorstQualityCalculator();
-      BestAverageWorstQualityCalculator validationQualityCalculator = new BestAverageWorstQualityCalculator();
-      validationQualityCalculator.Name = "BestAverageWorstValidationQualityCalculator";
-      validationQualityCalculator.GetVariableInfo("Quality").ActualName = "ValidationQuality";
-      validationQualityCalculator.GetVariableInfo("BestQuality").ActualName = "BestValidationQuality";
-      validationQualityCalculator.GetVariableInfo("AverageQuality").ActualName = "AverageValidationQuality";
-      validationQualityCalculator.GetVariableInfo("WorstQuality").ActualName = "WorstValidationQuality";
-      IOperator loggingOperator = CreateLoggingOperator();
-      Counter counter = new Counter();
-      counter.GetVariableInfo("Value").ActualName = "Generations";
-      IOperator loopCondition = CreateLoopCondition(seq);
-
-      seq.AddSubOperator(childCreater);
-      seq.AddSubOperator(replacement);
-      seq.AddSubOperator(solutionStorer);
-      seq.AddSubOperator(qualityCalculator);
-      seq.AddSubOperator(validationQualityCalculator);
-      seq.AddSubOperator(loggingOperator);
-      seq.AddSubOperator(counter);
-      seq.AddSubOperator(loopCondition);
-
-      main.OperatorGraph.AddOperator(seq);
-      main.OperatorGraph.InitialOperator = seq;
-      return main;
-    }
-
-    protected internal virtual IOperator CreateLoggingOperator() {
-      return new EmptyOperator();
-    }
-
-    protected internal virtual IOperator CreateLoopCondition(IOperator loop) {
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.Name = "Loop Condition";
-      LessThanComparator comparator = new LessThanComparator();
-      comparator.GetVariableInfo("LeftSide").ActualName = "Generations";
-      comparator.GetVariableInfo("RightSide").ActualName = "MaxGenerations";
-      comparator.GetVariableInfo("Result").ActualName = "GenerationsCondition";
-      ConditionalBranch cond = new ConditionalBranch();
-      cond.GetVariableInfo("Condition").ActualName = "GenerationsCondition";
-
-      seq.AddSubOperator(comparator);
-      seq.AddSubOperator(cond);
-
-      cond.AddSubOperator(loop);
-      return seq;
-    }
-
-    protected internal virtual IOperator CreateBestSolutionProcessor() {
-      SequentialProcessor seq = new SequentialProcessor();
-      ProgrammableOperator progOperator = new ProgrammableOperator();
-      progOperator.RemoveVariableInfo("Result");
-      progOperator.AddVariableInfo(new HeuristicLab.Core.VariableInfo("EvaluatedSolutions", "", typeof(IntData), VariableKind.In));
-      progOperator.Code = @"
-int evalSolutions = EvaluatedSolutions.Data;
-scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
-";
-      seq.AddSubOperator(progOperator);
-      return seq;
-    }
-
-    protected internal virtual IOperator CreateReplacement() {
-      CombinedOperator replacement = new CombinedOperator();
-      replacement.Name = "Replacement";
-      SequentialProcessor seq = new SequentialProcessor();
-      SequentialSubScopesProcessor seqScopeProc = new SequentialSubScopesProcessor();
-      SequentialProcessor selectedProc = new SequentialProcessor();
-      LeftSelector leftSelector = new LeftSelector();
-      leftSelector.GetVariableInfo("Selected").ActualName = "Elites";
-      RightReducer rightReducer = new RightReducer();
-
-      SequentialProcessor remainingProc = new SequentialProcessor();
-      RightSelector rightSelector = new RightSelector();
-      rightSelector.GetVariableInfo("Selected").ActualName = "Elites";
-      LeftReducer leftReducer = new LeftReducer();
-      MergingReducer mergingReducer = new MergingReducer();
-      Sorter sorter = new Sorter();
-      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
-      sorter.GetVariableInfo("Value").ActualName = "Quality";
-
-      seq.AddSubOperator(seqScopeProc);
-      seqScopeProc.AddSubOperator(selectedProc);
-      selectedProc.AddSubOperator(leftSelector);
-      selectedProc.AddSubOperator(rightReducer);
-
-      seqScopeProc.AddSubOperator(remainingProc);
-      remainingProc.AddSubOperator(rightSelector);
-      remainingProc.AddSubOperator(leftReducer);
-      seq.AddSubOperator(mergingReducer);
-      seq.AddSubOperator(sorter);
-      replacement.OperatorGraph.AddOperator(seq);
-      replacement.OperatorGraph.InitialOperator = seq;
-      return replacement;
-    }
-
-    protected internal virtual IOperator CreateChildCreater() {
-      CombinedOperator childCreater = new CombinedOperator();
-      childCreater.Name = "Create children";
-      SequentialProcessor seq = new SequentialProcessor();
-      OperatorExtractor selector = new OperatorExtractor();
-      selector.Name = "Selector (extr.)";
-      selector.GetVariableInfo("Operator").ActualName = "Selector";
-
-      SequentialSubScopesProcessor seqScopesProc = new SequentialSubScopesProcessor();
-      EmptyOperator emptyOpt = new EmptyOperator();
-      SequentialProcessor selectedProc = new SequentialProcessor();
-      ChildrenInitializer childInitializer = new ChildrenInitializer();
-      ((IntData)childInitializer.GetVariable("ParentsPerChild").Value).Data = 2;
-
-      OperatorExtractor crossover = new OperatorExtractor();
-      crossover.Name = "Crossover (extr.)";
-      crossover.GetVariableInfo("Operator").ActualName = "Crossover";
-      UniformSequentialSubScopesProcessor individualProc = new UniformSequentialSubScopesProcessor();
-      SequentialProcessor individualSeqProc = new SequentialProcessor();
-      StochasticBranch cond = new StochasticBranch();
-      cond.GetVariableInfo("Probability").ActualName = "MutationRate";
-      OperatorExtractor manipulator = new OperatorExtractor();
-      manipulator.Name = "Manipulator (extr.)";
-      manipulator.GetVariableInfo("Operator").ActualName = "Manipulator";
-      OperatorExtractor evaluator = new OperatorExtractor();
-      evaluator.Name = "Evaluator (extr.)";
-      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
-      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
-      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
-      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      Counter evalCounter = new Counter();
-      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
-      SubScopesRemover parentRefRemover = new SubScopesRemover();
-
-      Sorter sorter = new Sorter();
-      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
-      sorter.GetVariableInfo("Value").ActualName = "Quality";
-
-
-      seq.AddSubOperator(selector);
-      seq.AddSubOperator(seqScopesProc);
-      seqScopesProc.AddSubOperator(emptyOpt);
-      seqScopesProc.AddSubOperator(selectedProc);
-      selectedProc.AddSubOperator(childInitializer);
-      selectedProc.AddSubOperator(individualProc);
-      individualProc.AddSubOperator(individualSeqProc);
-      individualSeqProc.AddSubOperator(crossover);
-      individualSeqProc.AddSubOperator(cond);
-      cond.AddSubOperator(manipulator);
-      individualSeqProc.AddSubOperator(evaluator);
-      individualSeqProc.AddSubOperator(validationEvaluator);
-      individualSeqProc.AddSubOperator(evalCounter);
-      individualSeqProc.AddSubOperator(parentRefRemover);
-      selectedProc.AddSubOperator(sorter);
-
-      childCreater.OperatorGraph.AddOperator(seq);
-      childCreater.OperatorGraph.InitialOperator = seq;
-      return childCreater;
-    }
-
-    protected internal virtual IAnalyzerModel CreateGPModel(IScope bestModelScope) {
-      IAnalyzerModel model = new AnalyzerModel();
-      model.Predictor = bestModelScope.GetVariableValue<IPredictor>("Predictor", true);
-      Dataset ds = bestModelScope.GetVariableValue<Dataset>("Dataset", true);
-      model.Dataset = ds;
-      model.TargetVariable = ds.GetVariableName(bestModelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
-      model.TrainingSamplesStart = bestModelScope.GetVariableValue<IntData>("TrainingSamplesStart", true).Data;
-      model.TrainingSamplesEnd = bestModelScope.GetVariableValue<IntData>("TrainingSamplesEnd", true).Data;
-      model.ValidationSamplesStart = bestModelScope.GetVariableValue<IntData>("ValidationSamplesStart", true).Data;
-      model.ValidationSamplesEnd = bestModelScope.GetVariableValue<IntData>("ValidationSamplesEnd", true).Data;
-      model.TestSamplesStart = bestModelScope.GetVariableValue<IntData>("TestSamplesStart", true).Data;
-      model.TestSamplesEnd = bestModelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
-
-      model.TrainingMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data;
-      model.ValidationMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data;
-      model.TestMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TestMSE", false).Data;
-      model.TrainingCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data;
-      model.ValidationCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data;
-      model.TestCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data;
-      model.TrainingMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data;
-      model.ValidationMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data;
-      model.TestMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data;
-      model.TrainingMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data;
-      model.ValidationMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data;
-      model.TestMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data;
-      model.TrainingVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data;
-      model.ValidationVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data;
-      model.TestVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data;
-
-      ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
-      ItemList qualityImpacts = bestModelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
-      foreach (ItemList row in evaluationImpacts) {
-        string variableName = ((StringData)row[0]).Data;
-        double impact = ((DoubleData)row[1]).Data;
-        model.SetVariableEvaluationImpact(variableName, impact);
-        model.AddInputVariable(variableName);
-      }
-      foreach (ItemList row in qualityImpacts) {
-        string variableName = ((StringData)row[0]).Data;
-        double impact = ((DoubleData)row[1]).Data;
-        model.SetVariableQualityImpact(variableName, impact);
-        model.AddInputVariable(variableName);
-      }
-
-      return model;
-    }
-
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      AlgorithmBase clone = (AlgorithmBase)base.Clone(clonedObjects);
-      clonedObjects.Add(Guid, clone);
-      clone.engine = (SequentialEngine.SequentialEngine)Auxiliary.Clone(Engine, clonedObjects);
-      return clone;
-    }
-
-    protected VariableInjector GetVariableInjector() {
-      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-      // SequentialProcessor in GP
-      algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
-      return (VariableInjector)algorithm.SubOperators[2];
-    }
-
-    protected RandomInjector GetRandomInjector() {
-      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-      // SequentialProcessor in GP
-      algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
-      return (RandomInjector)algorithm.SubOperators[0];
-    }
-
-    #region Persistence Methods
-    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
-      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
-      node.AppendChild(PersistenceManager.Persist("Engine", Engine, document, persistedObjects));
-      return node;
-    }
-    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
-      base.Populate(node, restoredObjects);
-      engine = (SequentialEngine.SequentialEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
-    }
-    #endregion
-
-
-  }
-}
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs	(revision 2341)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs	(revision 2341)
@@ -0,0 +1,318 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.DataAnalysis;
+using HeuristicLab.GP.Interfaces;
+using HeuristicLab.Operators;
+using HeuristicLab.Modeling;
+using HeuristicLab.Logging;
+using HeuristicLab.Selection;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.GP.StructureIdentification {
+  public static class DefaultStructureIdentificationAlgorithmOperators {
+    public static IOperator CreateFunctionLibraryInjector() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "FunctionLibraryInjector";
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(new FunctionLibraryInjector());
+      seq.AddSubOperator(new HL3TreeEvaluatorInjector());
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    public static IOperator CreateProblemInjector() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "ProblemInjector";
+      SequentialProcessor seq = new SequentialProcessor();
+
+      seq.AddSubOperator(new ProblemInjector());
+      DatasetShuffler shuffler = new DatasetShuffler();
+      shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
+      shuffler.GetVariableInfo("ShuffleEnd").ActualName = "TrainingSamplesEnd";
+      seq.AddSubOperator(shuffler);
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    public static IOperator CreateInitialPopulationEvaluator() {
+      MeanSquaredErrorEvaluator eval = new MeanSquaredErrorEvaluator();
+      eval.Name = "Evaluator";
+      eval.GetVariableInfo("MSE").ActualName = "Quality";
+      eval.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
+      eval.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
+      return eval;
+    }
+
+    public static IOperator CreateEvaluator() {
+      return CreateInitialPopulationEvaluator();
+    }
+
+    public static IOperator CreateGenerationStepHook() {
+      CombinedOperator op = new CombinedOperator();
+      SequentialProcessor seq = new SequentialProcessor();
+      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
+      SequentialProcessor individualProc = new SequentialProcessor();
+      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
+      validationEvaluator.Name = "ValidationEvaluator";
+      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
+      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+
+      individualProc.AddSubOperator(validationEvaluator);
+
+      BestSolutionStorer solutionStorer = new BestSolutionStorer();
+      solutionStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
+      solutionStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
+
+      BestAverageWorstQualityCalculator validationQualityCalculator = new BestAverageWorstQualityCalculator();
+      validationQualityCalculator.Name = "BestAverageWorstValidationQualityCalculator";
+      validationQualityCalculator.GetVariableInfo("Quality").ActualName = "ValidationQuality";
+      validationQualityCalculator.GetVariableInfo("BestQuality").ActualName = "BestValidationQuality";
+      validationQualityCalculator.GetVariableInfo("AverageQuality").ActualName = "AverageValidationQuality";
+      validationQualityCalculator.GetVariableInfo("WorstQuality").ActualName = "WorstValidationQuality";
+
+      subScopesProc.AddSubOperator(individualProc);
+
+      seq.AddSubOperator(subScopesProc);
+      seq.AddSubOperator(solutionStorer);
+      seq.AddSubOperator(validationQualityCalculator);
+
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    public static IOperator CreatePostProcessingOperator() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "ModelAnalyser";
+      SequentialProcessor seq = new SequentialProcessor();
+      LeftReducer cleanUp = new LeftReducer();
+      cleanUp.Name = "Reset Population";
+      seq.AddSubOperator(cleanUp);
+
+      SolutionExtractor extractor = new SolutionExtractor();
+      extractor.GetVariableInfo("Scope").ActualName = "BestValidationSolution";
+      SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
+      SequentialProcessor solutionProc = new SequentialProcessor();
+
+      seq.AddSubOperator(extractor);
+      seq.AddSubOperator(seqSubScopeProc);
+      seqSubScopeProc.AddSubOperator(solutionProc);
+
+      HL3TreeEvaluatorInjector evaluatorInjector = new HL3TreeEvaluatorInjector();
+      evaluatorInjector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
+      evaluatorInjector.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+
+      #region MSE
+      MeanSquaredErrorEvaluator trainingMseEvaluator = new MeanSquaredErrorEvaluator();
+      trainingMseEvaluator.Name = "TrainingMseEvaluator";
+      trainingMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingMseEvaluator.GetVariableInfo("MSE").ActualName = "TrainingMSE";
+      trainingMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      MeanSquaredErrorEvaluator validationMseEvaluator = new MeanSquaredErrorEvaluator();
+      validationMseEvaluator.Name = "ValidationMseEvaluator";
+      validationMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationMseEvaluator.GetVariableInfo("MSE").ActualName = "ValidationMSE";
+      validationMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
+      testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
+      testMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestMSE";
+      testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion
+      #region MAPE
+      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
+      trainingMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
+      trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      validationMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
+      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
+      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      testMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testMapeEvaluator.Name = "TestMapeEvaluator";
+      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
+      testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion
+      #region MAPRE
+      MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
+      trainingMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
+      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
+      trainingMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      MeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
+      validationMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
+      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
+      validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
+      testMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testMapreEvaluator.Name = "TestMapreEvaluator";
+      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
+      testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion MAPRE
+      #region R2
+      CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
+      trainingR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingR2Evaluator.Name = "TrainingR2Evaluator";
+      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
+      trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
+      validationR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationR2Evaluator.Name = "ValidationR2Evaluator";
+      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
+      validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
+      testR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testR2Evaluator.Name = "TestR2Evaluator";
+      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
+      testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion
+      #region VAF
+      VarianceAccountedForEvaluator trainingVAFEvaluator = new VarianceAccountedForEvaluator();
+      trainingVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
+      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
+      trainingVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      VarianceAccountedForEvaluator validationVAFEvaluator = new VarianceAccountedForEvaluator();
+      validationVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
+      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
+      validationVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      VarianceAccountedForEvaluator testVAFEvaluator = new VarianceAccountedForEvaluator();
+      testVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testVAFEvaluator.Name = "TestVAFEvaluator";
+      testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
+      testVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion
+
+      solutionProc.AddSubOperator(evaluatorInjector);
+      solutionProc.AddSubOperator(trainingMseEvaluator);
+      solutionProc.AddSubOperator(validationMseEvaluator);
+      solutionProc.AddSubOperator(testMseEvaluator);
+      solutionProc.AddSubOperator(trainingMapeEvaluator);
+      solutionProc.AddSubOperator(validationMapeEvaluator);
+      solutionProc.AddSubOperator(testMapeEvaluator);
+      solutionProc.AddSubOperator(trainingMapreEvaluator);
+      solutionProc.AddSubOperator(validationMapreEvaluator);
+      solutionProc.AddSubOperator(testMapreEvaluator);
+      solutionProc.AddSubOperator(trainingR2Evaluator);
+      solutionProc.AddSubOperator(validationR2Evaluator);
+      solutionProc.AddSubOperator(testR2Evaluator);
+      solutionProc.AddSubOperator(trainingVAFEvaluator);
+      solutionProc.AddSubOperator(validationVAFEvaluator);
+      solutionProc.AddSubOperator(testVAFEvaluator);
+
+      #region variable impacts
+      // calculate and set variable impacts
+      VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
+      namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
+      PredictorBuilder predictorBuilder = new PredictorBuilder();
+      predictorBuilder.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+
+      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
+      evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      evaluationImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
+      qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+
+      solutionProc.AddSubOperator(namesExtractor);
+      solutionProc.AddSubOperator(predictorBuilder);
+      solutionProc.AddSubOperator(evaluationImpactCalculator);
+      solutionProc.AddSubOperator(qualityImpactCalculator);
+      #endregion
+
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    public static IAnalyzerModel CreateGPModel(IScope bestModelScope) {
+      IAnalyzerModel model = new AnalyzerModel();
+      model.Predictor = bestModelScope.GetVariableValue<IPredictor>("Predictor", true);
+      Dataset ds = bestModelScope.GetVariableValue<Dataset>("Dataset", true);
+      model.Dataset = ds;
+      model.TargetVariable = ds.GetVariableName(bestModelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
+      model.TrainingSamplesStart = bestModelScope.GetVariableValue<IntData>("TrainingSamplesStart", true).Data;
+      model.TrainingSamplesEnd = bestModelScope.GetVariableValue<IntData>("TrainingSamplesEnd", true).Data;
+      model.ValidationSamplesStart = bestModelScope.GetVariableValue<IntData>("ValidationSamplesStart", true).Data;
+      model.ValidationSamplesEnd = bestModelScope.GetVariableValue<IntData>("ValidationSamplesEnd", true).Data;
+      model.TestSamplesStart = bestModelScope.GetVariableValue<IntData>("TestSamplesStart", true).Data;
+      model.TestSamplesEnd = bestModelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
+
+      model.TrainingMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data;
+      model.ValidationMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data;
+      model.TestMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TestMSE", false).Data;
+      model.TrainingCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data;
+      model.ValidationCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data;
+      model.TestCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data;
+      model.TrainingMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data;
+      model.ValidationMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data;
+      model.TestMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data;
+      model.TrainingMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data;
+      model.ValidationMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data;
+      model.TestMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data;
+      model.TrainingVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data;
+      model.ValidationVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data;
+      model.TestVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data;
+
+      ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
+      ItemList qualityImpacts = bestModelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
+      foreach (ItemList row in evaluationImpacts) {
+        string variableName = ((StringData)row[0]).Data;
+        double impact = ((DoubleData)row[1]).Data;
+        model.SetVariableEvaluationImpact(variableName, impact);
+        model.AddInputVariable(variableName);
+      }
+      foreach (ItemList row in qualityImpacts) {
+        string variableName = ((StringData)row[0]).Data;
+        double impact = ((DoubleData)row[1]).Data;
+        model.SetVariableQualityImpact(variableName, impact);
+        model.AddInputVariable(variableName);
+      }
+
+      return model;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/GPEvaluatorBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/GPEvaluatorBase.cs	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/GPEvaluatorBase.cs	(revision 2341)
@@ -36,5 +36,5 @@
       AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("SamplesEnd", "End index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("UseEstimatedTargetValue", "Wether to use the original (measured) or the estimated (calculated) value for the target variable for autoregressive modelling", typeof(BoolData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("UseEstimatedTargetValue", "(optional) Wether to use the original (measured) or the estimated (calculated) value for the target variable for autoregressive modelling", typeof(BoolData), VariableKind.In));
     }
 
@@ -47,5 +47,6 @@
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
       int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
-      bool useEstimatedValues = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true).Data;
+      BoolData useEstimatedValuesData = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true, false);
+      bool useEstimatedValues = useEstimatedValuesData == null ? false : useEstimatedValuesData.Data;
       ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
       evaluator.PrepareForEvaluation(dataset, gpModel.FunctionTree);
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/HeuristicLab.GP.StructureIdentification-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/HeuristicLab.GP.StructureIdentification-3.3.csproj	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/HeuristicLab.GP.StructureIdentification-3.3.csproj	(revision 2341)
@@ -82,9 +82,10 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="BaseClasses\AlgorithmBase.cs" />
     <Compile Include="BaseClasses\FunctionTreeBase.cs" />
     <Compile Include="BaseClasses\TreeEvaluatorBase.cs" />
+    <Compile Include="DefaultStructureIdentificationOperators.cs" />
     <Compile Include="HL3TreeEvaluatorInjector.cs" />
     <Compile Include="HL2TreeEvaluatorInjector.cs" />
+    <Compile Include="OffspringSelectionGP.cs" />
     <Compile Include="PredictorBuilder.cs" />
     <Compile Include="Predictor.cs" />
@@ -96,4 +97,7 @@
     <Compile Include="PredictorView.Designer.cs">
       <DependentUpon>PredictorView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="StandardGP.cs">
+      <SubType>Code</SubType>
     </Compile>
     <Compile Include="Symbols\Addition.cs" />
@@ -128,18 +132,4 @@
     <Compile Include="Evaluators\MeanAbsolutePercentageOfRangeErrorEvaluator.cs" />
     <Compile Include="FunctionLibraryInjector.cs" />
-    <Compile Include="OffspringSelectionGP.cs" />
-    <Compile Include="OffSpringSelectionGpEditor.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="OffSpringSelectionGpEditor.Designer.cs">
-      <DependentUpon>OffSpringSelectionGpEditor.cs</DependentUpon>
-    </Compile>
-    <Compile Include="StandardGpEditor.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="StandardGpEditor.Designer.cs">
-      <DependentUpon>StandardGpEditor.cs</DependentUpon>
-    </Compile>
-    <Compile Include="StandardGP.cs" />
     <Compile Include="Evaluators\CoefficientOfDeterminationEvaluator.cs" />
     <Compile Include="Evaluators\UncertainMeanSquaredErrorEvaluator.cs" />
@@ -177,4 +167,8 @@
       <Name>HeuristicLab.Evolutionary-3.2</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.GP.Algorithms\3.2\HeuristicLab.GP.Algorithms-3.2.csproj">
+      <Project>{3127719F-110E-4558-8845-98559DBB422D}</Project>
+      <Name>HeuristicLab.GP.Algorithms-3.2</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.GP.Interfaces\3.3\HeuristicLab.GP.Interfaces-3.3.csproj">
       <Project>{924B6BEA-9A99-40FE-9334-5C01E8D540EC}</Project>
@@ -227,13 +221,6 @@
   </ItemGroup>
   <ItemGroup>
-    <EmbeddedResource Include="OffSpringSelectionGpEditor.resx">
-      <DependentUpon>OffSpringSelectionGpEditor.cs</DependentUpon>
-    </EmbeddedResource>
     <EmbeddedResource Include="PredictorView.resx">
       <DependentUpon>PredictorView.cs</DependentUpon>
-    </EmbeddedResource>
-    <EmbeddedResource Include="StandardGpEditor.resx">
-      <DependentUpon>StandardGpEditor.cs</DependentUpon>
-      <SubType>Designer</SubType>
     </EmbeddedResource>
   </ItemGroup>
Index: unk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.Designer.cs	(revision 2340)
+++ 	(revision )
@@ -1,404 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.GP.StructureIdentification {
-  partial class OffspringSelectionGpEditor {
-    /// <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 (chooseOperatorDialog != null) chooseOperatorDialog.Dispose();
-      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.executeButton = new System.Windows.Forms.Button();
-      this.tabControl = new System.Windows.Forms.TabControl();
-      this.parametersTabPage = new System.Windows.Forms.TabPage();
-      this.selectionPressureTextBox = new System.Windows.Forms.TextBox();
-      this.selectionPressureLabel = new System.Windows.Forms.Label();
-      this.viewProblemInitializationButton = new System.Windows.Forms.Button();
-      this.setProblemInitializationButton = new System.Windows.Forms.Button();
-      this.problemInitializationTextBox = new System.Windows.Forms.TextBox();
-      this.setRandomSeedRandomlyCheckBox = new System.Windows.Forms.CheckBox();
-      this.elitesTextBox = new System.Windows.Forms.TextBox();
-      this.problemInitializationLabel = new System.Windows.Forms.Label();
-      this.elitesLabel = new System.Windows.Forms.Label();
-      this.mutationRateTextBox = new System.Windows.Forms.TextBox();
-      this.mutationRateLabel = new System.Windows.Forms.Label();
-      this.maximumEvaluatedSolutionsTextBox = new System.Windows.Forms.TextBox();
-      this.maxEvaluatedSolutionsLabel = new System.Windows.Forms.Label();
-      this.randomSeedTextBox = new System.Windows.Forms.TextBox();
-      this.populationSizeTextBox = new System.Windows.Forms.TextBox();
-      this.setRandomSeedRandomlyLabel = new System.Windows.Forms.Label();
-      this.randomSeedLabel = new System.Windows.Forms.Label();
-      this.populationSizeLabel = new System.Windows.Forms.Label();
-      this.scopesTabPage = new System.Windows.Forms.TabPage();
-      this.scopeView = new HeuristicLab.Core.ScopeView();
-      this.abortButton = new System.Windows.Forms.Button();
-      this.resetButton = new System.Windows.Forms.Button();
-      this.cloneEngineButton = new System.Windows.Forms.Button();
-      this.tabControl.SuspendLayout();
-      this.parametersTabPage.SuspendLayout();
-      this.scopesTabPage.SuspendLayout();
-      this.SuspendLayout();
-      // 
-      // executeButton
-      // 
-      this.executeButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-      this.executeButton.Location = new System.Drawing.Point(0, 396);
-      this.executeButton.Name = "executeButton";
-      this.executeButton.Size = new System.Drawing.Size(75, 23);
-      this.executeButton.TabIndex = 1;
-      this.executeButton.Text = "&Execute";
-      this.executeButton.UseVisualStyleBackColor = true;
-      this.executeButton.Click += new System.EventHandler(this.executeButton_Click);
-      // 
-      // tabControl
-      // 
-      this.tabControl.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.tabControl.Controls.Add(this.parametersTabPage);
-      this.tabControl.Controls.Add(this.scopesTabPage);
-      this.tabControl.Location = new System.Drawing.Point(0, 0);
-      this.tabControl.Name = "tabControl";
-      this.tabControl.SelectedIndex = 0;
-      this.tabControl.Size = new System.Drawing.Size(526, 390);
-      this.tabControl.TabIndex = 0;
-      // 
-      // parametersTabPage
-      // 
-      this.parametersTabPage.Controls.Add(this.selectionPressureTextBox);
-      this.parametersTabPage.Controls.Add(this.selectionPressureLabel);
-      this.parametersTabPage.Controls.Add(this.viewProblemInitializationButton);
-      this.parametersTabPage.Controls.Add(this.setProblemInitializationButton);
-      this.parametersTabPage.Controls.Add(this.problemInitializationTextBox);
-      this.parametersTabPage.Controls.Add(this.setRandomSeedRandomlyCheckBox);
-      this.parametersTabPage.Controls.Add(this.elitesTextBox);
-      this.parametersTabPage.Controls.Add(this.problemInitializationLabel);
-      this.parametersTabPage.Controls.Add(this.elitesLabel);
-      this.parametersTabPage.Controls.Add(this.mutationRateTextBox);
-      this.parametersTabPage.Controls.Add(this.mutationRateLabel);
-      this.parametersTabPage.Controls.Add(this.maximumEvaluatedSolutionsTextBox);
-      this.parametersTabPage.Controls.Add(this.maxEvaluatedSolutionsLabel);
-      this.parametersTabPage.Controls.Add(this.randomSeedTextBox);
-      this.parametersTabPage.Controls.Add(this.populationSizeTextBox);
-      this.parametersTabPage.Controls.Add(this.setRandomSeedRandomlyLabel);
-      this.parametersTabPage.Controls.Add(this.randomSeedLabel);
-      this.parametersTabPage.Controls.Add(this.populationSizeLabel);
-      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
-      this.parametersTabPage.Name = "parametersTabPage";
-      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.parametersTabPage.Size = new System.Drawing.Size(518, 364);
-      this.parametersTabPage.TabIndex = 0;
-      this.parametersTabPage.Text = "Parameters";
-      this.parametersTabPage.UseVisualStyleBackColor = true;
-      // 
-      // selectionPressureTextBox
-      // 
-      this.selectionPressureTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.selectionPressureTextBox.Location = new System.Drawing.Point(218, 130);
-      this.selectionPressureTextBox.Name = "selectionPressureTextBox";
-      this.selectionPressureTextBox.Size = new System.Drawing.Size(186, 20);
-      this.selectionPressureTextBox.TabIndex = 17;
-      // 
-      // selectionPressureLabel
-      // 
-      this.selectionPressureLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.selectionPressureLabel.AutoSize = true;
-      this.selectionPressureLabel.Location = new System.Drawing.Point(65, 133);
-      this.selectionPressureLabel.Name = "selectionPressureLabel";
-      this.selectionPressureLabel.Size = new System.Drawing.Size(145, 13);
-      this.selectionPressureLabel.TabIndex = 16;
-      this.selectionPressureLabel.Text = "Maximum &Selection Pressure:";
-      // 
-      // viewProblemInitializationButton
-      // 
-      this.viewProblemInitializationButton.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.viewProblemInitializationButton.Location = new System.Drawing.Point(410, 241);
-      this.viewProblemInitializationButton.Name = "viewProblemInitializationButton";
-      this.viewProblemInitializationButton.Size = new System.Drawing.Size(53, 20);
-      this.viewProblemInitializationButton.TabIndex = 14;
-      this.viewProblemInitializationButton.Text = "View...";
-      this.viewProblemInitializationButton.UseVisualStyleBackColor = true;
-      this.viewProblemInitializationButton.Click += new System.EventHandler(this.viewProblemInjectorButton_Click);
-      // 
-      // setProblemInitializationButton
-      // 
-      this.setProblemInitializationButton.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.setProblemInitializationButton.Location = new System.Drawing.Point(469, 241);
-      this.setProblemInitializationButton.Name = "setProblemInitializationButton";
-      this.setProblemInitializationButton.Size = new System.Drawing.Size(43, 20);
-      this.setProblemInitializationButton.TabIndex = 15;
-      this.setProblemInitializationButton.Text = "Set...";
-      this.setProblemInitializationButton.UseVisualStyleBackColor = true;
-      this.setProblemInitializationButton.Click += new System.EventHandler(this.setProblemInitializationButton_Click);
-      // 
-      // problemInitializationTextBox
-      // 
-      this.problemInitializationTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.problemInitializationTextBox.Location = new System.Drawing.Point(218, 241);
-      this.problemInitializationTextBox.Name = "problemInitializationTextBox";
-      this.problemInitializationTextBox.ReadOnly = true;
-      this.problemInitializationTextBox.Size = new System.Drawing.Size(186, 20);
-      this.problemInitializationTextBox.TabIndex = 13;
-      // 
-      // setRandomSeedRandomlyCheckBox
-      // 
-      this.setRandomSeedRandomlyCheckBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.setRandomSeedRandomlyCheckBox.AutoSize = true;
-      this.setRandomSeedRandomlyCheckBox.Location = new System.Drawing.Point(218, 6);
-      this.setRandomSeedRandomlyCheckBox.Name = "setRandomSeedRandomlyCheckBox";
-      this.setRandomSeedRandomlyCheckBox.Size = new System.Drawing.Size(15, 14);
-      this.setRandomSeedRandomlyCheckBox.TabIndex = 1;
-      this.setRandomSeedRandomlyCheckBox.UseVisualStyleBackColor = true;
-      this.setRandomSeedRandomlyCheckBox.CheckedChanged += new System.EventHandler(this.setRandomSeedRandomlyCheckBox_CheckedChanged);
-      // 
-      // elitesTextBox
-      // 
-      this.elitesTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.elitesTextBox.Location = new System.Drawing.Point(218, 182);
-      this.elitesTextBox.Name = "elitesTextBox";
-      this.elitesTextBox.Size = new System.Drawing.Size(186, 20);
-      this.elitesTextBox.TabIndex = 11;
-      // 
-      // problemInitializationLabel
-      // 
-      this.problemInitializationLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.problemInitializationLabel.AutoSize = true;
-      this.problemInitializationLabel.Location = new System.Drawing.Point(65, 244);
-      this.problemInitializationLabel.Name = "problemInitializationLabel";
-      this.problemInitializationLabel.Size = new System.Drawing.Size(105, 13);
-      this.problemInitializationLabel.TabIndex = 12;
-      this.problemInitializationLabel.Text = "&Problem Initialization:";
-      // 
-      // elitesLabel
-      // 
-      this.elitesLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.elitesLabel.AutoSize = true;
-      this.elitesLabel.Location = new System.Drawing.Point(66, 185);
-      this.elitesLabel.Name = "elitesLabel";
-      this.elitesLabel.Size = new System.Drawing.Size(35, 13);
-      this.elitesLabel.TabIndex = 10;
-      this.elitesLabel.Text = "&Elites:";
-      // 
-      // mutationRateTextBox
-      // 
-      this.mutationRateTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.mutationRateTextBox.Location = new System.Drawing.Point(218, 156);
-      this.mutationRateTextBox.Name = "mutationRateTextBox";
-      this.mutationRateTextBox.Size = new System.Drawing.Size(186, 20);
-      this.mutationRateTextBox.TabIndex = 9;
-      // 
-      // mutationRateLabel
-      // 
-      this.mutationRateLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.mutationRateLabel.AutoSize = true;
-      this.mutationRateLabel.Location = new System.Drawing.Point(66, 159);
-      this.mutationRateLabel.Name = "mutationRateLabel";
-      this.mutationRateLabel.Size = new System.Drawing.Size(77, 13);
-      this.mutationRateLabel.TabIndex = 8;
-      this.mutationRateLabel.Text = "&Mutation Rate:";
-      // 
-      // maximumEvaluatedSolutionsTextBox
-      // 
-      this.maximumEvaluatedSolutionsTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.maximumEvaluatedSolutionsTextBox.Location = new System.Drawing.Point(218, 104);
-      this.maximumEvaluatedSolutionsTextBox.Name = "maximumEvaluatedSolutionsTextBox";
-      this.maximumEvaluatedSolutionsTextBox.Size = new System.Drawing.Size(186, 20);
-      this.maximumEvaluatedSolutionsTextBox.TabIndex = 7;
-      // 
-      // maxEvaluatedSolutionsLabel
-      // 
-      this.maxEvaluatedSolutionsLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.maxEvaluatedSolutionsLabel.AutoSize = true;
-      this.maxEvaluatedSolutionsLabel.Location = new System.Drawing.Point(65, 107);
-      this.maxEvaluatedSolutionsLabel.Name = "maxEvaluatedSolutionsLabel";
-      this.maxEvaluatedSolutionsLabel.Size = new System.Drawing.Size(130, 13);
-      this.maxEvaluatedSolutionsLabel.TabIndex = 6;
-      this.maxEvaluatedSolutionsLabel.Text = "Max. E&valuated Solutions:";
-      // 
-      // randomSeedTextBox
-      // 
-      this.randomSeedTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.randomSeedTextBox.Location = new System.Drawing.Point(218, 26);
-      this.randomSeedTextBox.Name = "randomSeedTextBox";
-      this.randomSeedTextBox.Size = new System.Drawing.Size(186, 20);
-      this.randomSeedTextBox.TabIndex = 3;
-      // 
-      // populationSizeTextBox
-      // 
-      this.populationSizeTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.populationSizeTextBox.Location = new System.Drawing.Point(218, 78);
-      this.populationSizeTextBox.Name = "populationSizeTextBox";
-      this.populationSizeTextBox.Size = new System.Drawing.Size(186, 20);
-      this.populationSizeTextBox.TabIndex = 5;
-      // 
-      // setRandomSeedRandomlyLabel
-      // 
-      this.setRandomSeedRandomlyLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.setRandomSeedRandomlyLabel.AutoSize = true;
-      this.setRandomSeedRandomlyLabel.Location = new System.Drawing.Point(65, 6);
-      this.setRandomSeedRandomlyLabel.Name = "setRandomSeedRandomlyLabel";
-      this.setRandomSeedRandomlyLabel.Size = new System.Drawing.Size(147, 13);
-      this.setRandomSeedRandomlyLabel.TabIndex = 0;
-      this.setRandomSeedRandomlyLabel.Text = "Set &Random Seed Randomly:";
-      // 
-      // randomSeedLabel
-      // 
-      this.randomSeedLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.randomSeedLabel.AutoSize = true;
-      this.randomSeedLabel.Location = new System.Drawing.Point(65, 29);
-      this.randomSeedLabel.Name = "randomSeedLabel";
-      this.randomSeedLabel.Size = new System.Drawing.Size(78, 13);
-      this.randomSeedLabel.TabIndex = 2;
-      this.randomSeedLabel.Text = "&Random Seed:";
-      // 
-      // populationSizeLabel
-      // 
-      this.populationSizeLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.populationSizeLabel.AutoSize = true;
-      this.populationSizeLabel.Location = new System.Drawing.Point(65, 81);
-      this.populationSizeLabel.Name = "populationSizeLabel";
-      this.populationSizeLabel.Size = new System.Drawing.Size(83, 13);
-      this.populationSizeLabel.TabIndex = 4;
-      this.populationSizeLabel.Text = "&Population Size:";
-      // 
-      // scopesTabPage
-      // 
-      this.scopesTabPage.Controls.Add(this.scopeView);
-      this.scopesTabPage.Location = new System.Drawing.Point(4, 22);
-      this.scopesTabPage.Name = "scopesTabPage";
-      this.scopesTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.scopesTabPage.Size = new System.Drawing.Size(518, 364);
-      this.scopesTabPage.TabIndex = 2;
-      this.scopesTabPage.Text = "Scopes";
-      this.scopesTabPage.UseVisualStyleBackColor = true;
-      // 
-      // scopeView
-      // 
-      this.scopeView.Caption = "Scope";
-      this.scopeView.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.scopeView.Location = new System.Drawing.Point(3, 3);
-      this.scopeView.Name = "scopeView";
-      this.scopeView.Scope = null;
-      this.scopeView.Size = new System.Drawing.Size(512, 358);
-      this.scopeView.TabIndex = 0;
-      // 
-      // abortButton
-      // 
-      this.abortButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-      this.abortButton.Enabled = false;
-      this.abortButton.Location = new System.Drawing.Point(81, 396);
-      this.abortButton.Name = "abortButton";
-      this.abortButton.Size = new System.Drawing.Size(75, 23);
-      this.abortButton.TabIndex = 2;
-      this.abortButton.Text = "&Abort";
-      this.abortButton.UseVisualStyleBackColor = true;
-      this.abortButton.Click += new System.EventHandler(this.abortButton_Click);
-      // 
-      // resetButton
-      // 
-      this.resetButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-      this.resetButton.Location = new System.Drawing.Point(162, 396);
-      this.resetButton.Name = "resetButton";
-      this.resetButton.Size = new System.Drawing.Size(75, 23);
-      this.resetButton.TabIndex = 3;
-      this.resetButton.Text = "&Reset";
-      this.resetButton.UseVisualStyleBackColor = true;
-      this.resetButton.Click += new System.EventHandler(this.resetButton_Click);
-      // 
-      // cloneEngineButton
-      // 
-      this.cloneEngineButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-      this.cloneEngineButton.Location = new System.Drawing.Point(420, 396);
-      this.cloneEngineButton.Name = "cloneEngineButton";
-      this.cloneEngineButton.Size = new System.Drawing.Size(106, 23);
-      this.cloneEngineButton.TabIndex = 4;
-      this.cloneEngineButton.Text = "&Clone Engine...";
-      this.cloneEngineButton.UseVisualStyleBackColor = true;
-      this.cloneEngineButton.Click += new System.EventHandler(this.cloneEngineButton_Click);
-      // 
-      // OffspringSelectionGpEditor
-      // 
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-      this.Controls.Add(this.tabControl);
-      this.Controls.Add(this.cloneEngineButton);
-      this.Controls.Add(this.resetButton);
-      this.Controls.Add(this.abortButton);
-      this.Controls.Add(this.executeButton);
-      this.Name = "OffspringSelectionGpEditor";
-      this.Size = new System.Drawing.Size(526, 419);
-      this.tabControl.ResumeLayout(false);
-      this.parametersTabPage.ResumeLayout(false);
-      this.parametersTabPage.PerformLayout();
-      this.scopesTabPage.ResumeLayout(false);
-      this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Button executeButton;
-    protected System.Windows.Forms.TabControl tabControl;
-    protected System.Windows.Forms.TabPage parametersTabPage;
-    private System.Windows.Forms.Button abortButton;
-    private System.Windows.Forms.Button resetButton;
-    private System.Windows.Forms.TextBox mutationRateTextBox;
-    private System.Windows.Forms.Label mutationRateLabel;
-    private System.Windows.Forms.TextBox populationSizeTextBox;
-    private System.Windows.Forms.Label populationSizeLabel;
-    private System.Windows.Forms.TabPage scopesTabPage;
-    private System.Windows.Forms.TextBox maximumEvaluatedSolutionsTextBox;
-    private System.Windows.Forms.Label maxEvaluatedSolutionsLabel;
-    private System.Windows.Forms.TextBox elitesTextBox;
-    private System.Windows.Forms.Label elitesLabel;
-    private System.Windows.Forms.TextBox randomSeedTextBox;
-    private System.Windows.Forms.Label setRandomSeedRandomlyLabel;
-    private System.Windows.Forms.Label randomSeedLabel;
-    private System.Windows.Forms.CheckBox setRandomSeedRandomlyCheckBox;
-    private System.Windows.Forms.Label problemInitializationLabel;
-    private System.Windows.Forms.Button cloneEngineButton;
-    private System.Windows.Forms.TextBox problemInitializationTextBox;
-    private System.Windows.Forms.Button setProblemInitializationButton;
-    private HeuristicLab.Core.ScopeView scopeView;
-    private System.Windows.Forms.Button viewProblemInitializationButton;
-    private System.Windows.Forms.TextBox selectionPressureTextBox;
-    private System.Windows.Forms.Label selectionPressureLabel;
-  }
-}
Index: unk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.cs	(revision 2340)
+++ 	(revision )
@@ -1,137 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.PluginInfrastructure;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.GP.StructureIdentification {
-  public partial class OffspringSelectionGpEditor : EditorBase {
-    private ChooseOperatorDialog chooseOperatorDialog;
-
-    public OffspringSelectionGP OffspringSelectionGP {
-      get { return (OffspringSelectionGP)Item; }
-      set { base.Item = value; }
-    }
-
-    public OffspringSelectionGpEditor() {
-      InitializeComponent();
-    }
-    public OffspringSelectionGpEditor(OffspringSelectionGP osgp)
-      : this() {
-      OffspringSelectionGP = osgp;
-    }
-
-    protected override void RemoveItemEvents() {
-      OffspringSelectionGP.Engine.ExceptionOccurred -= new EventHandler<ExceptionEventArgs>(Engine_ExceptionOccurred);
-      OffspringSelectionGP.Engine.Finished -= new EventHandler(Engine_Finished);
-      scopeView.Scope = null;
-      base.RemoveItemEvents();
-    }
-
-    protected override void AddItemEvents() {
-      base.AddItemEvents();
-      OffspringSelectionGP.Engine.ExceptionOccurred += new EventHandler<ExceptionEventArgs>(Engine_ExceptionOccurred);
-      OffspringSelectionGP.Engine.Finished += new EventHandler(Engine_Finished);
-      SetDataBinding();
-      scopeView.Scope = OffspringSelectionGP.Engine.GlobalScope;
-    }
-
-    protected override void UpdateControls() {
-      base.UpdateControls();
-      if (OffspringSelectionGP == null) {
-        tabControl.Enabled = false;
-      } else {
-        tabControl.Enabled = true;
-        problemInitializationTextBox.Text = OffspringSelectionGP.ProblemInjector.GetType().Name;
-      }
-    }
-
-    protected virtual void SetDataBinding() {
-      setRandomSeedRandomlyCheckBox.DataBindings.Add("Checked", OffspringSelectionGP, "SetSeedRandomly");
-      randomSeedTextBox.DataBindings.Add("Text", OffspringSelectionGP, "RandomSeed");
-      populationSizeTextBox.DataBindings.Add("Text", OffspringSelectionGP, "PopulationSize");
-      maximumEvaluatedSolutionsTextBox.DataBindings.Add("Text", OffspringSelectionGP, "MaxEvaluatedSolutions");
-      selectionPressureTextBox.DataBindings.Add("Text", OffspringSelectionGP, "SelectionPressureLimit");
-      mutationRateTextBox.DataBindings.Add("Text", OffspringSelectionGP, "MutationRate");
-      elitesTextBox.DataBindings.Add("Text", OffspringSelectionGP, "Elites");
-    }
-
-    #region Button Events
-    private void viewProblemInjectorButton_Click(object sender, EventArgs e) {
-      IView view = OffspringSelectionGP.ProblemInjector.CreateView();
-      if(view != null)
-        PluginManager.ControlManager.ShowControl(view);
-    }
-
-    private void setProblemInitializationButton_Click(object sender, EventArgs e) {
-      if (chooseOperatorDialog == null) chooseOperatorDialog = new ChooseOperatorDialog();
-      if (chooseOperatorDialog.ShowDialog(this) == DialogResult.OK) {
-        OffspringSelectionGP.ProblemInjector = chooseOperatorDialog.Operator;
-        problemInitializationTextBox.Text = OffspringSelectionGP.ProblemInjector.GetType().Name;
-      }
-    }
-    private void executeButton_Click(object sender, EventArgs e) {
-      executeButton.Enabled = false;
-      abortButton.Enabled = true;
-      resetButton.Enabled = false;
-      OffspringSelectionGP.Engine.Execute();
-    }
-    private void abortButton_Click(object sender, EventArgs e) {
-      OffspringSelectionGP.Engine.Abort();
-    }
-    private void resetButton_Click(object sender, EventArgs e) {
-      OffspringSelectionGP.Engine.Reset();
-    }
-    private void cloneEngineButton_Click(object sender, EventArgs e) {
-      IEngine clone = (IEngine)OffspringSelectionGP.Engine.Clone();
-      IEditor editor = ((IEditable)clone).CreateEditor();
-      PluginManager.ControlManager.ShowControl(editor);
-    }
-    #endregion
-
-    #region Engine Events
-    private delegate void OnExceptionEventDelegate(object sender, ExceptionEventArgs e);
-    private void Engine_ExceptionOccurred(object sender, ExceptionEventArgs e) {
-      if (InvokeRequired)
-        Invoke(new OnExceptionEventDelegate(Engine_ExceptionOccurred), sender, e);
-      else
-        Auxiliary.ShowErrorMessageBox(e.Exception);
-    }
-    private void Engine_Finished(object sender, EventArgs e) {
-      if(InvokeRequired)
-        Invoke((EventHandler)Engine_Finished, sender, e);
-      else {
-        scopeView.Refresh();
-        executeButton.Enabled = true;
-        abortButton.Enabled = false;
-        resetButton.Enabled = true;
-      }
-    }
-    #endregion
-
-    private void setRandomSeedRandomlyCheckBox_CheckedChanged(object sender, EventArgs e) {
-      randomSeedTextBox.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
-      randomSeedLabel.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
-    }
-  }
-}
Index: unk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.resx
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.resx	(revision 2340)
+++ 	(revision )
@@ -1,120 +1,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffspringSelectionGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffspringSelectionGP.cs	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffspringSelectionGP.cs	(revision 2341)
@@ -29,198 +29,80 @@
 using HeuristicLab.Selection;
 using HeuristicLab.Selection.OffspringSelection;
+using HeuristicLab.Modeling;
+using HeuristicLab.DataAnalysis;
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class OffspringSelectionGP : StandardGP {
-    public override string Name { get { return "OffspringSelectionGP"; } }
+  public class OffspringSelectionGP : HeuristicLab.GP.Algorithms.OffspringSelectionGP, IAlgorithm {
+    public override string Name { get { return "OffspringSelectionGP - StructureIdentification"; } }
 
-    public virtual int MaxEvaluatedSolutions {
-      get { return GetVariableInjector().GetVariable("MaxEvaluatedSolutions").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("MaxEvaluatedSolutions").GetValue<IntData>().Data = value; }
+    public virtual int TargetVariable {
+      get { return ProblemInjector.GetVariableValue<IntData>("TargetVariable", null, false).Data; }
+      set { ProblemInjector.GetVariableValue<IntData>("TargetVariable", null, false).Data = value; }
     }
 
-    public virtual double SelectionPressureLimit {
-      get { return GetVariableInjector().GetVariable("SelectionPressureLimit").GetValue<DoubleData>().Data; }
-      set { GetVariableInjector().GetVariable("SelectionPressureLimit").GetValue<DoubleData>().Data = value; }
+    public virtual Dataset Dataset {
+      get { return ProblemInjector.GetVariableValue<Dataset>("Dataset", null, false); }
+      set { ProblemInjector.GetVariable("Dataset").Value = value; }
     }
 
-    public virtual double ComparisonFactor {
-      get { return GetVariableInjector().GetVariable("ComparisonFactor").GetValue<DoubleData>().Data; }
-      set { GetVariableInjector().GetVariable("ComparisonFactor").GetValue<DoubleData>().Data = value; }
+    public virtual IAnalyzerModel Model {
+      get {
+        if (!Engine.Terminated)
+          throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
+        else
+          return CreateGPModel();
+      }
     }
 
-    public virtual double SuccessRatioLimit {
-      get { return GetVariableInjector().GetVariable("SuccessRatioLimit").GetValue<DoubleData>().Data; }
-      set { GetVariableInjector().GetVariable("SuccessRatioLimit").GetValue<DoubleData>().Data = value; }
+    public virtual double PunishmentFactor {
+      get { return GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data = value; }
     }
 
-    public override int MaxGenerations {
-      get { throw new NotSupportedException(); }
-      set { /* ignore */ }
-    }
-
-    public override int TournamentSize {
-      get { throw new NotSupportedException(); }
-      set { /* ignore */ }
+    public override IOperator ProblemInjector {
+      get { return GetProblemInjector().OperatorGraph.InitialOperator.SubOperators[0]; }
+      set {
+        value.Name = "ProblemInjector";
+        CombinedOperator problemInjector = GetProblemInjector();
+        problemInjector.OperatorGraph.RemoveOperator(ProblemInjector.Guid);
+        problemInjector.OperatorGraph.AddOperator(value);
+        problemInjector.OperatorGraph.InitialOperator.AddSubOperator(value, 0);
+      }
     }
 
     public OffspringSelectionGP()
       : base() {
-      PopulationSize = 1000;
-      Parents = 20;
-      MaxEvaluatedSolutions = 5000000;
-      SelectionPressureLimit = 400;
-      ComparisonFactor = 1.0;
-      SuccessRatioLimit = 1.0;
+      PunishmentFactor = 10.0;
     }
 
-    protected internal override IOperator CreateGlobalInjector() {
-      VariableInjector injector = (VariableInjector)base.CreateGlobalInjector();
-      injector.RemoveVariable("TournamentSize");
-      injector.RemoveVariable("MaxGenerations");
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxEvaluatedSolutions", new IntData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("ComparisonFactor", new DoubleData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("SelectionPressureLimit", new DoubleData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("SuccessRatioLimit", new DoubleData()));
+    protected override IOperator CreateFunctionLibraryInjector() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateFunctionLibraryInjector();
+    }
+
+    protected override IOperator CreateProblemInjector() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateProblemInjector();
+    }
+
+    protected override IOperator CreateInitialPopulationEvaluator() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateInitialPopulationEvaluator();
+    }
+
+    protected override IOperator CreateEvaluationOperator() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateEvaluator();
+    }
+
+
+    protected override IOperator CreateGenerationStepHook() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateGenerationStepHook();
+    }
+
+    protected override VariableInjector CreateGlobalInjector() {
+      VariableInjector injector = base.CreateGlobalInjector();
+      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData()));
       return injector;
     }
 
-    protected internal override IOperator CreateSelector() {
-      CombinedOperator selector = new CombinedOperator();
-      selector.Name = "Selector";
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.Name = "Selector";
-      EmptyOperator emptyOp = new EmptyOperator();
-      ProportionalSelector femaleSelector = new ProportionalSelector();
-      femaleSelector.GetVariableInfo("Selected").ActualName = "Parents";
-      femaleSelector.GetVariableValue<BoolData>("CopySelected", null, false).Data = true;
 
-      RandomSelector maleSelector = new RandomSelector();
-      maleSelector.GetVariableInfo("Selected").ActualName = "Parents";
-      maleSelector.GetVariableValue<BoolData>("CopySelected", null, false).Data = true;
-      SequentialSubScopesProcessor seqSubScopesProc = new SequentialSubScopesProcessor();
-      RightChildReducer rightChildReducer = new RightChildReducer();
-      SubScopesMixer mixer = new SubScopesMixer();
-
-      seqSubScopesProc.AddSubOperator(femaleSelector);
-      seqSubScopesProc.AddSubOperator(emptyOp);
-
-      seq.AddSubOperator(maleSelector);
-      seq.AddSubOperator(seqSubScopesProc);
-      seq.AddSubOperator(rightChildReducer);
-      seq.AddSubOperator(mixer);
-
-      selector.OperatorGraph.AddOperator(seq);
-      selector.OperatorGraph.InitialOperator = seq;
-      return selector;
-    }
-
-    protected internal override IOperator CreateChildCreater() {
-      CombinedOperator childCreater = new CombinedOperator();
-      childCreater.Name = "Create children";
-      SequentialProcessor main = new SequentialProcessor();
-      SequentialProcessor seq = new SequentialProcessor();
-      SequentialProcessor offspringSelectionSeq = new SequentialProcessor();
-      OperatorExtractor selector = new OperatorExtractor();
-      selector.Name = "Selector (extr.)";
-      selector.GetVariableInfo("Operator").ActualName = "Selector";
-      SequentialSubScopesProcessor seqSubScopesProc = new SequentialSubScopesProcessor();
-      EmptyOperator emptyOp = new EmptyOperator();
-      OffspringSelector offspringSelector = new OffspringSelector();
-      ChildrenInitializer childInitializer = new ChildrenInitializer();
-      UniformSequentialSubScopesProcessor individualProc = new UniformSequentialSubScopesProcessor();
-      SequentialProcessor individualSeqProc = new SequentialProcessor();
-      OperatorExtractor crossover = new OperatorExtractor();
-      crossover.Name = "Crossover (extr.)";
-      crossover.GetVariableInfo("Operator").ActualName = "Crossover";
-      StochasticBranch cond = new StochasticBranch();
-      cond.GetVariableInfo("Probability").ActualName = "MutationRate";
-      OperatorExtractor manipulator = new OperatorExtractor();
-      manipulator.Name = "Manipulator (extr.)";
-      manipulator.GetVariableInfo("Operator").ActualName = "Manipulator";
-      OperatorExtractor evaluator = new OperatorExtractor();
-      evaluator.Name = "Evaluator (extr.)";
-      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
-      Counter evalCounter = new Counter();
-      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
-      WeightedOffspringFitnessComparer offspringFitnessComparer = new WeightedOffspringFitnessComparer();
-      SubScopesRemover parentScopesRemover = new SubScopesRemover();
-
-      Sorter sorter = new Sorter();
-      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
-      sorter.GetVariableInfo("Value").ActualName = "Quality";
-
-      UniformSequentialSubScopesProcessor validationEvaluator = new UniformSequentialSubScopesProcessor();
-      MeanSquaredErrorEvaluator validationQualityEvaluator = new MeanSquaredErrorEvaluator();
-      validationQualityEvaluator.Name = "ValidationMeanSquaredErrorEvaluator";
-      validationQualityEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
-      validationQualityEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationQualityEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-
-      main.AddSubOperator(seq);
-      seq.AddSubOperator(selector);
-      seq.AddSubOperator(seqSubScopesProc);
-      seqSubScopesProc.AddSubOperator(emptyOp);
-      seqSubScopesProc.AddSubOperator(offspringSelectionSeq);
-      seq.AddSubOperator(offspringSelector);
-      offspringSelector.AddSubOperator(seq);
-
-      offspringSelectionSeq.AddSubOperator(childInitializer);
-      offspringSelectionSeq.AddSubOperator(individualProc);
-      offspringSelectionSeq.AddSubOperator(sorter);
-
-      individualProc.AddSubOperator(individualSeqProc);
-      individualSeqProc.AddSubOperator(crossover);
-      individualSeqProc.AddSubOperator(cond);
-      cond.AddSubOperator(manipulator);
-      individualSeqProc.AddSubOperator(evaluator);
-      individualSeqProc.AddSubOperator(evalCounter);
-      individualSeqProc.AddSubOperator(offspringFitnessComparer);
-      individualSeqProc.AddSubOperator(parentScopesRemover);
-
-      SequentialSubScopesProcessor seqSubScopesProc2 = new SequentialSubScopesProcessor();
-      main.AddSubOperator(seqSubScopesProc2);
-      seqSubScopesProc2.AddSubOperator(emptyOp);
-
-      SequentialProcessor newGenProc = new SequentialProcessor();
-      newGenProc.AddSubOperator(sorter);
-      newGenProc.AddSubOperator(validationEvaluator);
-      seqSubScopesProc2.AddSubOperator(newGenProc);
-
-      validationEvaluator.AddSubOperator(validationQualityEvaluator);
-
-      childCreater.OperatorGraph.AddOperator(main);
-      childCreater.OperatorGraph.InitialOperator = main;
-      return childCreater;
-    }
-
-    protected internal override IOperator CreateLoopCondition(IOperator loop) {
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.Name = "Loop Condition";
-      LessThanComparator generationsComparator = new LessThanComparator();
-      generationsComparator.GetVariableInfo("LeftSide").ActualName = "EvaluatedSolutions";
-      generationsComparator.GetVariableInfo("RightSide").ActualName = "MaxEvaluatedSolutions";
-      generationsComparator.GetVariableInfo("Result").ActualName = "EvaluatedSolutionsCondition";
-
-      LessThanComparator selPresComparator = new LessThanComparator();
-      selPresComparator.GetVariableInfo("LeftSide").ActualName = "SelectionPressure";
-      selPresComparator.GetVariableInfo("RightSide").ActualName = "SelectionPressureLimit";
-      selPresComparator.GetVariableInfo("Result").ActualName = "SelectionPressureCondition";
-
-      ConditionalBranch generationsCond = new ConditionalBranch();
-      generationsCond.GetVariableInfo("Condition").ActualName = "EvaluatedSolutionsCondition";
-
-      ConditionalBranch selPresCond = new ConditionalBranch();
-      selPresCond.GetVariableInfo("Condition").ActualName = "SelectionPressureCondition";
-
-      seq.AddSubOperator(generationsComparator);
-      seq.AddSubOperator(selPresComparator);
-      seq.AddSubOperator(generationsCond);
-      generationsCond.AddSubOperator(selPresCond);
-      selPresCond.AddSubOperator(loop);
-
-      return seq;
-    }
-
-    protected internal override IOperator CreateLoggingOperator() {
+    protected override IOperator CreateLoggingOperator() {
       CombinedOperator loggingOperator = new CombinedOperator();
       loggingOperator.Name = "Logging";
@@ -239,8 +121,6 @@
       QualityLogger qualityLogger = new QualityLogger();
       QualityLogger validationQualityLogger = new QualityLogger();
-      validationQualityLogger.Name = "ValidationQualityLogger";
       validationQualityLogger.GetVariableInfo("Quality").ActualName = "ValidationQuality";
       validationQualityLogger.GetVariableInfo("QualityLog").ActualName = "ValidationQualityLog";
-
       seq.AddSubOperator(collector);
       seq.AddSubOperator(qualityLogger);
@@ -252,19 +132,21 @@
     }
 
-
-    public override IEditor CreateEditor() {
-      return new OffspringSelectionGpEditor(this);
-    }
-
-    public override IView CreateView() {
-      return new OffspringSelectionGpEditor(this);
+    protected override IOperator CreatePostProcessingOperator() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator();
     }
 
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       OffspringSelectionGP clone = (OffspringSelectionGP)base.Clone(clonedObjects);
-      clone.SelectionPressureLimit = SelectionPressureLimit;
-      clone.SuccessRatioLimit = SuccessRatioLimit;
-      clone.ComparisonFactor = ComparisonFactor;
+      clone.PunishmentFactor = PunishmentFactor;
       return clone;
+    }
+
+    protected CombinedOperator GetProblemInjector() {
+      return (CombinedOperator)GetInitializationOperator().SubOperators[0];
+    }
+
+    private IAnalyzerModel CreateGPModel() {
+      IScope bestModelScope = Engine.GlobalScope.SubScopes[0];
+      return DefaultStructureIdentificationAlgorithmOperators.CreateGPModel(bestModelScope);
     }
   }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs	(revision 2340)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs	(revision 2341)
@@ -21,79 +21,51 @@
 
 using HeuristicLab.Core;
-using HeuristicLab.DataAnalysis;
 using HeuristicLab.Operators;
 using HeuristicLab.Selection;
 using HeuristicLab.Logging;
 using HeuristicLab.Data;
-using HeuristicLab.Operators.Programmable;
+using HeuristicLab.GP.Operators;
 using HeuristicLab.Modeling;
-using HeuristicLab.GP.Operators;
+using System.Collections.Generic;
+using System;
+using HeuristicLab.DataAnalysis;
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class StandardGP : AlgorithmBase, IEditable {
+  public class StandardGP : HeuristicLab.GP.Algorithms.StandardGP, IAlgorithm {
 
-    public override string Name { get { return "StandardGP"; } }
+    public override string Name { get { return "StandardGP - StructureIdentification"; } }
 
-    public override int TargetVariable {
+    public virtual int TargetVariable {
       get { return ProblemInjector.GetVariableValue<IntData>("TargetVariable", null, false).Data; }
       set { ProblemInjector.GetVariableValue<IntData>("TargetVariable", null, false).Data = value; }
     }
 
-    public override Dataset Dataset {
+    public virtual Dataset Dataset {
       get { return ProblemInjector.GetVariableValue<Dataset>("Dataset", null, false); }
       set { ProblemInjector.GetVariable("Dataset").Value = value; }
     }
 
-    public virtual int MaxGenerations {
-      get { return GetVariableInjector().GetVariable("MaxGenerations").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("MaxGenerations").GetValue<IntData>().Data = value; }
-    }
-
-    public virtual int TournamentSize {
-      get { return GetVariableInjector().GetVariable("TournamentSize").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("TournamentSize").GetValue<IntData>().Data = value; }
-    }
-
-    public double FullTreeShakingFactor {
-      get { return GetVariableInjector().GetVariable("FullTreeShakingFactor").GetValue<DoubleData>().Data; }
-      set { GetVariableInjector().GetVariable("FullTreeShakingFactor").GetValue<DoubleData>().Data = value; }
-    }
-
-    public double OnePointShakingFactor {
-      get { return GetVariableInjector().GetVariable("OnePointShakingFactor").GetValue<DoubleData>().Data; }
-      set { GetVariableInjector().GetVariable("OnePointShakingFactor").GetValue<DoubleData>().Data = value; }
-    }
-
-    public int MinInitialTreeSize {
-      get { return GetVariableInjector().GetVariable("MinInitialTreeSize").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("MinInitialTreeSize").GetValue<IntData>().Data = value; }
-    }
-
-    public override int MaxTreeSize {
+    public virtual IAnalyzerModel Model {
       get {
-        return base.MaxTreeSize;
-      }
-      set {
-        base.MaxTreeSize = value;
-        MinInitialTreeSize = value / 2;
+        if (!Engine.Terminated)
+          throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
+        else
+          return CreateGPModel();
       }
     }
 
-    public override int PopulationSize {
-      get {
-        return base.PopulationSize;
-      }
-      set {
-        base.PopulationSize = value;
-        Parents = 2 * value;
-      }
+    public virtual double PunishmentFactor {
+      get { return GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data = value; }
     }
 
     public override IOperator ProblemInjector {
-      get { return base.ProblemInjector.SubOperators[0]; }
+      get { return GetProblemInjector().OperatorGraph.InitialOperator.SubOperators[0]; }
       set {
         value.Name = "ProblemInjector";
-        base.ProblemInjector.RemoveSubOperator(0);
-        base.ProblemInjector.AddSubOperator(value, 0);
+        CombinedOperator problemInjector = GetProblemInjector();
+        problemInjector.OperatorGraph.RemoveOperator(ProblemInjector.Guid);
+        problemInjector.OperatorGraph.AddOperator(value);
+        problemInjector.OperatorGraph.InitialOperator.AddSubOperator(value, 0);
       }
     }
@@ -101,107 +73,36 @@
     public StandardGP()
       : base() {
-      PopulationSize = 10000;
-      MaxGenerations = 500;
-      TournamentSize = 7;
-      MutationRate = 0.15;
-      Elites = 1;
-      MaxTreeSize = 100;
-      MaxTreeHeight = 10;
-      FullTreeShakingFactor = 0.1;
-      OnePointShakingFactor = 1.0;
-      UseEstimatedTargetValue = false;
-      SetSeedRandomly = true;
+
+      PunishmentFactor = 10.0;
     }
 
-    protected internal override IOperator CreateProblemInjector() {
-      SequentialProcessor seq = new SequentialProcessor();
-      var probInject = new ProblemInjector();
-      probInject.GetVariableInfo("MaxNumberOfTrainingSamples").Local = true;
-      probInject.AddVariable(new HeuristicLab.Core.Variable("MaxNumberOfTrainingSamples", new IntData(5000)));
-
-      var shuffler = new DatasetShuffler();
-      shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
-      shuffler.GetVariableInfo("ShuffleEnd").ActualName = "TrainingSamplesEnd";
-
-      seq.AddSubOperator(probInject);
-      seq.AddSubOperator(shuffler);
-      return seq;
+    protected override IOperator CreateFunctionLibraryInjector() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateFunctionLibraryInjector();
     }
 
-    protected internal override IOperator CreateSelector() {
-      TournamentSelector selector = new TournamentSelector();
-      selector.Name = "Selector";
-      selector.GetVariableInfo("Selected").ActualName = "Parents";
-      selector.GetVariableInfo("GroupSize").Local = false;
-      selector.RemoveVariable("GroupSize");
-      selector.GetVariableInfo("GroupSize").ActualName = "TournamentSize";
-      return selector;
+    protected override IOperator CreateProblemInjector() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateProblemInjector();
     }
 
-    protected internal override IOperator CreateGlobalInjector() {
-      VariableInjector globalInjector = (VariableInjector)base.CreateGlobalInjector();
-      globalInjector.AddVariable(new HeuristicLab.Core.Variable("TournamentSize", new IntData()));
-      globalInjector.AddVariable(new HeuristicLab.Core.Variable("MaxGenerations", new IntData()));
-      globalInjector.AddVariable(new HeuristicLab.Core.Variable("FullTreeShakingFactor", new DoubleData()));
-      globalInjector.AddVariable(new HeuristicLab.Core.Variable("OnePointShakingFactor", new DoubleData()));
-      globalInjector.AddVariable(new HeuristicLab.Core.Variable("MinInitialTreeSize", new IntData()));
-      return globalInjector;
+    protected override IOperator CreateInitialPopulationEvaluator() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateInitialPopulationEvaluator();
     }
 
-    protected internal override IOperator CreateCrossover() {
-      StandardCrossOver crossover = new StandardCrossOver();
-      crossover.Name = "Crossover";
-      return crossover;
+    protected override IOperator CreateEvaluationOperator() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateEvaluator();
     }
 
-    protected internal override IOperator CreateTreeCreator() {
-      ProbabilisticTreeCreator treeCreator = new ProbabilisticTreeCreator();
-      treeCreator.Name = "Tree generator";
-      treeCreator.GetVariableInfo("MinTreeSize").ActualName = "MinInitialTreeSize";
-      return treeCreator;
+
+    protected override IOperator CreateGenerationStepHook() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreateGenerationStepHook();
     }
 
-    protected internal override IOperator CreateFunctionLibraryInjector() {
-      FunctionLibraryInjector funLibInjector = new FunctionLibraryInjector();
-      funLibInjector.GetVariableValue<BoolData>("Xor", null, false).Data = false;
-      funLibInjector.GetVariableValue<BoolData>("Average", null, false).Data = false;
-      return funLibInjector;
+    protected override VariableInjector CreateGlobalInjector() {
+      VariableInjector injector = base.CreateGlobalInjector();
+      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData()));
+      return injector;
     }
 
-    protected internal override IOperator CreateManipulator() {
-      CombinedOperator manipulator = new CombinedOperator();
-      manipulator.Name = "Manipulator";
-      StochasticMultiBranch multibranch = new StochasticMultiBranch();
-      FullTreeShaker fullTreeShaker = new FullTreeShaker();
-      fullTreeShaker.GetVariableInfo("ShakingFactor").ActualName = "FullTreeShakingFactor";
-
-      OnePointShaker onepointShaker = new OnePointShaker();
-      onepointShaker.GetVariableInfo("ShakingFactor").ActualName = "OnePointShakingFactor";
-      ChangeNodeTypeManipulation changeNodeTypeManipulation = new ChangeNodeTypeManipulation();
-      CutOutNodeManipulation cutOutNodeManipulation = new CutOutNodeManipulation();
-      DeleteSubTreeManipulation deleteSubTreeManipulation = new DeleteSubTreeManipulation();
-      SubstituteSubTreeManipulation substituteSubTreeManipulation = new SubstituteSubTreeManipulation();
-
-      IOperator[] manipulators = new IOperator[] {
-        onepointShaker, fullTreeShaker,
-        changeNodeTypeManipulation,
-        cutOutNodeManipulation,
-        deleteSubTreeManipulation,
-        substituteSubTreeManipulation};
-
-      DoubleArrayData probabilities = new DoubleArrayData(new double[manipulators.Length]);
-      for (int i = 0; i < manipulators.Length; i++) {
-        probabilities.Data[i] = 1.0;
-        multibranch.AddSubOperator(manipulators[i]);
-      }
-      multibranch.GetVariableInfo("Probabilities").Local = true;
-      multibranch.AddVariable(new HeuristicLab.Core.Variable("Probabilities", probabilities));
-
-      manipulator.OperatorGraph.AddOperator(multibranch);
-      manipulator.OperatorGraph.InitialOperator = multibranch;
-      return manipulator;
-    }
-
-    protected internal override IOperator CreateLoggingOperator() {
+    protected override IOperator CreateLoggingOperator() {
       CombinedOperator loggingOperator = new CombinedOperator();
       loggingOperator.Name = "Logging";
@@ -216,15 +117,10 @@
       names.Add(new StringData("AverageValidationQuality"));
       names.Add(new StringData("WorstValidationQuality"));
-      LinechartInjector lineChartInjector = new LinechartInjector();
-      lineChartInjector.GetVariableInfo("Linechart").ActualName = "Quality Linechart";
-      lineChartInjector.GetVariable("NumberOfLines").GetValue<IntData>().Data = 6;
+      names.Add(new StringData("EvaluatedSolutions"));
       QualityLogger qualityLogger = new QualityLogger();
       QualityLogger validationQualityLogger = new QualityLogger();
-      validationQualityLogger.Name = "ValidationQualityLogger";
       validationQualityLogger.GetVariableInfo("Quality").ActualName = "ValidationQuality";
       validationQualityLogger.GetVariableInfo("QualityLog").ActualName = "ValidationQualityLog";
-
       seq.AddSubOperator(collector);
-      seq.AddSubOperator(lineChartInjector);
       seq.AddSubOperator(qualityLogger);
       seq.AddSubOperator(validationQualityLogger);
@@ -235,10 +131,21 @@
     }
 
-    public virtual IEditor CreateEditor() {
-      return new StandardGpEditor(this);
+    protected override IOperator CreatePostProcessingOperator() {
+      return DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator();
     }
 
-    public override IView CreateView() {
-      return new StandardGpEditor(this);
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      StandardGP clone = (StandardGP)base.Clone(clonedObjects);
+      clone.PunishmentFactor = PunishmentFactor;
+      return clone;
+    }
+
+    protected CombinedOperator GetProblemInjector() {
+      return (CombinedOperator)GetInitializationOperator().SubOperators[0];
+    }
+
+    private IAnalyzerModel CreateGPModel() {
+      IScope bestModelScope = Engine.GlobalScope.SubScopes[0];
+      return DefaultStructureIdentificationAlgorithmOperators.CreateGPModel(bestModelScope);
     }
   }
Index: unk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.Designer.cs	(revision 2340)
+++ 	(revision )
@@ -1,380 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.GP.StructureIdentification {
-  partial class StandardGpEditor {
-    /// <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 (chooseOperatorDialog != null) chooseOperatorDialog.Dispose();
-      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.executeButton = new System.Windows.Forms.Button();
-      this.tabControl = new System.Windows.Forms.TabControl();
-      this.parametersTabPage = new System.Windows.Forms.TabPage();
-      this.viewProblemInitializationButton = new System.Windows.Forms.Button();
-      this.setProblemInitializationButton = new System.Windows.Forms.Button();
-      this.problemInitializationTextBox = new System.Windows.Forms.TextBox();
-      this.setRandomSeedRandomlyCheckBox = new System.Windows.Forms.CheckBox();
-      this.elitesTextBox = new System.Windows.Forms.TextBox();
-      this.problemInitializationLabel = new System.Windows.Forms.Label();
-      this.elitesLabel = new System.Windows.Forms.Label();
-      this.mutationRateTextBox = new System.Windows.Forms.TextBox();
-      this.mutationRateLabel = new System.Windows.Forms.Label();
-      this.maximumGenerationsTextBox = new System.Windows.Forms.TextBox();
-      this.maximumGenerationsLabel = new System.Windows.Forms.Label();
-      this.randomSeedTextBox = new System.Windows.Forms.TextBox();
-      this.populationSizeTextBox = new System.Windows.Forms.TextBox();
-      this.setRandomSeedRandomlyLabel = new System.Windows.Forms.Label();
-      this.randomSeedLabel = new System.Windows.Forms.Label();
-      this.populationSizeLabel = new System.Windows.Forms.Label();
-      this.scopesTabPage = new System.Windows.Forms.TabPage();
-      this.scopeView = new HeuristicLab.Core.ScopeView();
-      this.abortButton = new System.Windows.Forms.Button();
-      this.resetButton = new System.Windows.Forms.Button();
-      this.cloneEngineButton = new System.Windows.Forms.Button();
-      this.tabControl.SuspendLayout();
-      this.parametersTabPage.SuspendLayout();
-      this.scopesTabPage.SuspendLayout();
-      this.SuspendLayout();
-      // 
-      // executeButton
-      // 
-      this.executeButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-      this.executeButton.Location = new System.Drawing.Point(0, 396);
-      this.executeButton.Name = "executeButton";
-      this.executeButton.Size = new System.Drawing.Size(75, 23);
-      this.executeButton.TabIndex = 1;
-      this.executeButton.Text = "&Execute";
-      this.executeButton.UseVisualStyleBackColor = true;
-      this.executeButton.Click += new System.EventHandler(this.executeButton_Click);
-      // 
-      // tabControl
-      // 
-      this.tabControl.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.tabControl.Controls.Add(this.parametersTabPage);
-      this.tabControl.Controls.Add(this.scopesTabPage);
-      this.tabControl.Location = new System.Drawing.Point(0, 0);
-      this.tabControl.Name = "tabControl";
-      this.tabControl.SelectedIndex = 0;
-      this.tabControl.Size = new System.Drawing.Size(526, 390);
-      this.tabControl.TabIndex = 0;
-      // 
-      // parametersTabPage
-      // 
-      this.parametersTabPage.Controls.Add(this.viewProblemInitializationButton);
-      this.parametersTabPage.Controls.Add(this.setProblemInitializationButton);
-      this.parametersTabPage.Controls.Add(this.problemInitializationTextBox);
-      this.parametersTabPage.Controls.Add(this.setRandomSeedRandomlyCheckBox);
-      this.parametersTabPage.Controls.Add(this.elitesTextBox);
-      this.parametersTabPage.Controls.Add(this.problemInitializationLabel);
-      this.parametersTabPage.Controls.Add(this.elitesLabel);
-      this.parametersTabPage.Controls.Add(this.mutationRateTextBox);
-      this.parametersTabPage.Controls.Add(this.mutationRateLabel);
-      this.parametersTabPage.Controls.Add(this.maximumGenerationsTextBox);
-      this.parametersTabPage.Controls.Add(this.maximumGenerationsLabel);
-      this.parametersTabPage.Controls.Add(this.randomSeedTextBox);
-      this.parametersTabPage.Controls.Add(this.populationSizeTextBox);
-      this.parametersTabPage.Controls.Add(this.setRandomSeedRandomlyLabel);
-      this.parametersTabPage.Controls.Add(this.randomSeedLabel);
-      this.parametersTabPage.Controls.Add(this.populationSizeLabel);
-      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
-      this.parametersTabPage.Name = "parametersTabPage";
-      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.parametersTabPage.Size = new System.Drawing.Size(518, 364);
-      this.parametersTabPage.TabIndex = 0;
-      this.parametersTabPage.Text = "Parameters";
-      this.parametersTabPage.UseVisualStyleBackColor = true;
-      // 
-      // viewProblemInitializationButton
-      // 
-      this.viewProblemInitializationButton.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.viewProblemInitializationButton.Location = new System.Drawing.Point(410, 208);
-      this.viewProblemInitializationButton.Name = "viewProblemInitializationButton";
-      this.viewProblemInitializationButton.Size = new System.Drawing.Size(53, 20);
-      this.viewProblemInitializationButton.TabIndex = 14;
-      this.viewProblemInitializationButton.Text = "View...";
-      this.viewProblemInitializationButton.UseVisualStyleBackColor = true;
-      this.viewProblemInitializationButton.Click += new System.EventHandler(this.viewProblemInjectorButton_Click);
-      // 
-      // setProblemInitializationButton
-      // 
-      this.setProblemInitializationButton.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.setProblemInitializationButton.Location = new System.Drawing.Point(469, 208);
-      this.setProblemInitializationButton.Name = "setProblemInitializationButton";
-      this.setProblemInitializationButton.Size = new System.Drawing.Size(43, 20);
-      this.setProblemInitializationButton.TabIndex = 15;
-      this.setProblemInitializationButton.Text = "Set...";
-      this.setProblemInitializationButton.UseVisualStyleBackColor = true;
-      this.setProblemInitializationButton.Click += new System.EventHandler(this.setProblemInitializationButton_Click);
-      // 
-      // problemInitializationTextBox
-      // 
-      this.problemInitializationTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.problemInitializationTextBox.Location = new System.Drawing.Point(218, 208);
-      this.problemInitializationTextBox.Name = "problemInitializationTextBox";
-      this.problemInitializationTextBox.ReadOnly = true;
-      this.problemInitializationTextBox.Size = new System.Drawing.Size(186, 20);
-      this.problemInitializationTextBox.TabIndex = 13;
-      // 
-      // setRandomSeedRandomlyCheckBox
-      // 
-      this.setRandomSeedRandomlyCheckBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.setRandomSeedRandomlyCheckBox.AutoSize = true;
-      this.setRandomSeedRandomlyCheckBox.Location = new System.Drawing.Point(218, 6);
-      this.setRandomSeedRandomlyCheckBox.Name = "setRandomSeedRandomlyCheckBox";
-      this.setRandomSeedRandomlyCheckBox.Size = new System.Drawing.Size(15, 14);
-      this.setRandomSeedRandomlyCheckBox.TabIndex = 1;
-      this.setRandomSeedRandomlyCheckBox.UseVisualStyleBackColor = true;
-      this.setRandomSeedRandomlyCheckBox.CheckedChanged += new System.EventHandler(this.setRandomSeedRandomlyCheckBox_CheckedChanged);
-      // 
-      // elitesTextBox
-      // 
-      this.elitesTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.elitesTextBox.Location = new System.Drawing.Point(218, 156);
-      this.elitesTextBox.Name = "elitesTextBox";
-      this.elitesTextBox.Size = new System.Drawing.Size(186, 20);
-      this.elitesTextBox.TabIndex = 11;
-      // 
-      // problemInitializationLabel
-      // 
-      this.problemInitializationLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.problemInitializationLabel.AutoSize = true;
-      this.problemInitializationLabel.Location = new System.Drawing.Point(65, 211);
-      this.problemInitializationLabel.Name = "problemInitializationLabel";
-      this.problemInitializationLabel.Size = new System.Drawing.Size(105, 13);
-      this.problemInitializationLabel.TabIndex = 12;
-      this.problemInitializationLabel.Text = "&Problem Initialization:";
-      // 
-      // elitesLabel
-      // 
-      this.elitesLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.elitesLabel.AutoSize = true;
-      this.elitesLabel.Location = new System.Drawing.Point(65, 159);
-      this.elitesLabel.Name = "elitesLabel";
-      this.elitesLabel.Size = new System.Drawing.Size(35, 13);
-      this.elitesLabel.TabIndex = 10;
-      this.elitesLabel.Text = "&Elites:";
-      // 
-      // mutationRateTextBox
-      // 
-      this.mutationRateTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.mutationRateTextBox.Location = new System.Drawing.Point(218, 130);
-      this.mutationRateTextBox.Name = "mutationRateTextBox";
-      this.mutationRateTextBox.Size = new System.Drawing.Size(186, 20);
-      this.mutationRateTextBox.TabIndex = 9;
-      // 
-      // mutationRateLabel
-      // 
-      this.mutationRateLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.mutationRateLabel.AutoSize = true;
-      this.mutationRateLabel.Location = new System.Drawing.Point(65, 133);
-      this.mutationRateLabel.Name = "mutationRateLabel";
-      this.mutationRateLabel.Size = new System.Drawing.Size(77, 13);
-      this.mutationRateLabel.TabIndex = 8;
-      this.mutationRateLabel.Text = "&Mutation Rate:";
-      // 
-      // maximumGenerationsTextBox
-      // 
-      this.maximumGenerationsTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.maximumGenerationsTextBox.Location = new System.Drawing.Point(218, 104);
-      this.maximumGenerationsTextBox.Name = "maximumGenerationsTextBox";
-      this.maximumGenerationsTextBox.Size = new System.Drawing.Size(186, 20);
-      this.maximumGenerationsTextBox.TabIndex = 7;
-      // 
-      // maximumGenerationsLabel
-      // 
-      this.maximumGenerationsLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.maximumGenerationsLabel.AutoSize = true;
-      this.maximumGenerationsLabel.Location = new System.Drawing.Point(65, 107);
-      this.maximumGenerationsLabel.Name = "maximumGenerationsLabel";
-      this.maximumGenerationsLabel.Size = new System.Drawing.Size(114, 13);
-      this.maximumGenerationsLabel.TabIndex = 6;
-      this.maximumGenerationsLabel.Text = "Maximum &Generations:";
-      // 
-      // randomSeedTextBox
-      // 
-      this.randomSeedTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.randomSeedTextBox.Location = new System.Drawing.Point(218, 26);
-      this.randomSeedTextBox.Name = "randomSeedTextBox";
-      this.randomSeedTextBox.Size = new System.Drawing.Size(186, 20);
-      this.randomSeedTextBox.TabIndex = 3;
-      // 
-      // populationSizeTextBox
-      // 
-      this.populationSizeTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.populationSizeTextBox.Location = new System.Drawing.Point(218, 78);
-      this.populationSizeTextBox.Name = "populationSizeTextBox";
-      this.populationSizeTextBox.Size = new System.Drawing.Size(186, 20);
-      this.populationSizeTextBox.TabIndex = 5;
-      // 
-      // setRandomSeedRandomlyLabel
-      // 
-      this.setRandomSeedRandomlyLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.setRandomSeedRandomlyLabel.AutoSize = true;
-      this.setRandomSeedRandomlyLabel.Location = new System.Drawing.Point(65, 6);
-      this.setRandomSeedRandomlyLabel.Name = "setRandomSeedRandomlyLabel";
-      this.setRandomSeedRandomlyLabel.Size = new System.Drawing.Size(147, 13);
-      this.setRandomSeedRandomlyLabel.TabIndex = 0;
-      this.setRandomSeedRandomlyLabel.Text = "Set &Random Seed Randomly:";
-      // 
-      // randomSeedLabel
-      // 
-      this.randomSeedLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.randomSeedLabel.AutoSize = true;
-      this.randomSeedLabel.Location = new System.Drawing.Point(65, 29);
-      this.randomSeedLabel.Name = "randomSeedLabel";
-      this.randomSeedLabel.Size = new System.Drawing.Size(78, 13);
-      this.randomSeedLabel.TabIndex = 2;
-      this.randomSeedLabel.Text = "&Random Seed:";
-      // 
-      // populationSizeLabel
-      // 
-      this.populationSizeLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.populationSizeLabel.AutoSize = true;
-      this.populationSizeLabel.Location = new System.Drawing.Point(65, 81);
-      this.populationSizeLabel.Name = "populationSizeLabel";
-      this.populationSizeLabel.Size = new System.Drawing.Size(83, 13);
-      this.populationSizeLabel.TabIndex = 4;
-      this.populationSizeLabel.Text = "&Population Size:";
-      // 
-      // scopesTabPage
-      // 
-      this.scopesTabPage.Controls.Add(this.scopeView);
-      this.scopesTabPage.Location = new System.Drawing.Point(4, 22);
-      this.scopesTabPage.Name = "scopesTabPage";
-      this.scopesTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.scopesTabPage.Size = new System.Drawing.Size(518, 364);
-      this.scopesTabPage.TabIndex = 2;
-      this.scopesTabPage.Text = "Scopes";
-      this.scopesTabPage.UseVisualStyleBackColor = true;
-      // 
-      // scopeView
-      // 
-      this.scopeView.Caption = "Scope";
-      this.scopeView.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.scopeView.Location = new System.Drawing.Point(3, 3);
-      this.scopeView.Name = "scopeView";
-      this.scopeView.Scope = null;
-      this.scopeView.Size = new System.Drawing.Size(512, 358);
-      this.scopeView.TabIndex = 0;
-      // 
-      // abortButton
-      // 
-      this.abortButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-      this.abortButton.Enabled = false;
-      this.abortButton.Location = new System.Drawing.Point(81, 396);
-      this.abortButton.Name = "abortButton";
-      this.abortButton.Size = new System.Drawing.Size(75, 23);
-      this.abortButton.TabIndex = 2;
-      this.abortButton.Text = "&Abort";
-      this.abortButton.UseVisualStyleBackColor = true;
-      this.abortButton.Click += new System.EventHandler(this.abortButton_Click);
-      // 
-      // resetButton
-      // 
-      this.resetButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-      this.resetButton.Location = new System.Drawing.Point(162, 396);
-      this.resetButton.Name = "resetButton";
-      this.resetButton.Size = new System.Drawing.Size(75, 23);
-      this.resetButton.TabIndex = 3;
-      this.resetButton.Text = "&Reset";
-      this.resetButton.UseVisualStyleBackColor = true;
-      this.resetButton.Click += new System.EventHandler(this.resetButton_Click);
-      // 
-      // cloneEngineButton
-      // 
-      this.cloneEngineButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-      this.cloneEngineButton.Location = new System.Drawing.Point(420, 396);
-      this.cloneEngineButton.Name = "cloneEngineButton";
-      this.cloneEngineButton.Size = new System.Drawing.Size(106, 23);
-      this.cloneEngineButton.TabIndex = 4;
-      this.cloneEngineButton.Text = "&Clone Engine...";
-      this.cloneEngineButton.UseVisualStyleBackColor = true;
-      this.cloneEngineButton.Click += new System.EventHandler(this.cloneEngineButton_Click);
-      // 
-      // StandardGpEditor
-      // 
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-      this.Controls.Add(this.tabControl);
-      this.Controls.Add(this.cloneEngineButton);
-      this.Controls.Add(this.resetButton);
-      this.Controls.Add(this.abortButton);
-      this.Controls.Add(this.executeButton);
-      this.Name = "StandardGpEditor";
-      this.Size = new System.Drawing.Size(526, 419);
-      this.tabControl.ResumeLayout(false);
-      this.parametersTabPage.ResumeLayout(false);
-      this.parametersTabPage.PerformLayout();
-      this.scopesTabPage.ResumeLayout(false);
-      this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Button executeButton;
-    protected System.Windows.Forms.TabControl tabControl;
-    protected System.Windows.Forms.TabPage parametersTabPage;
-    private System.Windows.Forms.Button abortButton;
-    private System.Windows.Forms.Button resetButton;
-    private System.Windows.Forms.TextBox mutationRateTextBox;
-    private System.Windows.Forms.Label mutationRateLabel;
-    private System.Windows.Forms.TextBox populationSizeTextBox;
-    private System.Windows.Forms.Label populationSizeLabel;
-    private System.Windows.Forms.TabPage scopesTabPage;
-    private System.Windows.Forms.TextBox maximumGenerationsTextBox;
-    private System.Windows.Forms.Label maximumGenerationsLabel;
-    private System.Windows.Forms.TextBox elitesTextBox;
-    private System.Windows.Forms.Label elitesLabel;
-    private System.Windows.Forms.TextBox randomSeedTextBox;
-    private System.Windows.Forms.Label setRandomSeedRandomlyLabel;
-    private System.Windows.Forms.Label randomSeedLabel;
-    private System.Windows.Forms.CheckBox setRandomSeedRandomlyCheckBox;
-    private System.Windows.Forms.Label problemInitializationLabel;
-    private System.Windows.Forms.Button cloneEngineButton;
-    private System.Windows.Forms.TextBox problemInitializationTextBox;
-    private System.Windows.Forms.Button setProblemInitializationButton;
-    private HeuristicLab.Core.ScopeView scopeView;
-    private System.Windows.Forms.Button viewProblemInitializationButton;
-  }
-}
Index: unk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.cs	(revision 2340)
+++ 	(revision )
@@ -1,135 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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;
-using HeuristicLab.PluginInfrastructure;
-
-namespace HeuristicLab.GP.StructureIdentification {
-  public partial class StandardGpEditor : EditorBase {
-    private ChooseOperatorDialog chooseOperatorDialog;
-
-    public StandardGP StandardGP {
-      get { return (StandardGP)Item; }
-      set { base.Item = value; }
-    }
-
-    public StandardGpEditor() {
-      InitializeComponent();
-    }
-    public StandardGpEditor(StandardGP sgp)
-      : this() {
-      StandardGP = sgp;
-    }
-
-    protected override void RemoveItemEvents() {
-      StandardGP.Engine.ExceptionOccurred -= new EventHandler<ExceptionEventArgs>(Engine_ExceptionOccurred);
-      StandardGP.Engine.Finished -= new EventHandler(Engine_Finished);
-      scopeView.Scope = null;
-      base.RemoveItemEvents();
-    }
-    protected override void AddItemEvents() {
-      base.AddItemEvents();
-      StandardGP.Engine.ExceptionOccurred += new EventHandler<ExceptionEventArgs>(Engine_ExceptionOccurred);
-      StandardGP.Engine.Finished += new EventHandler(Engine_Finished);
-      SetDataBinding();
-      scopeView.Scope = StandardGP.Engine.GlobalScope;
-    }
-
-    protected override void UpdateControls() {
-      base.UpdateControls();
-      if(StandardGP == null) {
-        tabControl.Enabled = false;
-      } else {
-        tabControl.Enabled = true;
-        problemInitializationTextBox.Text = StandardGP.ProblemInjector.GetType().Name;
-      }
-    }
-
-    protected virtual void SetDataBinding() {
-      setRandomSeedRandomlyCheckBox.DataBindings.Add("Checked", StandardGP, "SetSeedRandomly");
-      randomSeedTextBox.DataBindings.Add("Text", StandardGP, "RandomSeed");
-      populationSizeTextBox.DataBindings.Add("Text", StandardGP, "PopulationSize");
-      maximumGenerationsTextBox.DataBindings.Add("Text", StandardGP, "MaxGenerations");
-      mutationRateTextBox.DataBindings.Add("Text", StandardGP, "MutationRate");
-      elitesTextBox.DataBindings.Add("Text", StandardGP, "Elites");
-    }
-
-    #region Button Events
-    private void viewProblemInjectorButton_Click(object sender, EventArgs e) {
-      IView view = StandardGP.ProblemInjector.CreateView();
-      if(view != null)
-        PluginManager.ControlManager.ShowControl(view);
-    }
-
-    private void setProblemInitializationButton_Click(object sender, EventArgs e) {
-      if (chooseOperatorDialog == null) chooseOperatorDialog = new ChooseOperatorDialog();
-      if (chooseOperatorDialog.ShowDialog(this) == DialogResult.OK) {
-        StandardGP.ProblemInjector = chooseOperatorDialog.Operator;
-        problemInitializationTextBox.Text = StandardGP.ProblemInjector.GetType().Name;
-      }
-    }
-    private void executeButton_Click(object sender, EventArgs e) {
-      executeButton.Enabled = false;
-      abortButton.Enabled = true;
-      resetButton.Enabled = false;
-      StandardGP.Engine.Execute();
-    }
-    private void abortButton_Click(object sender, EventArgs e) {
-      StandardGP.Engine.Abort();
-    }
-    private void resetButton_Click(object sender, EventArgs e) {
-      StandardGP.Engine.Reset();
-    }
-    private void cloneEngineButton_Click(object sender, EventArgs e) {
-      IEngine clone = (IEngine)StandardGP.Engine.Clone();
-      IEditor editor = ((IEditable)clone).CreateEditor();
-      PluginManager.ControlManager.ShowControl(editor);
-    }
-    #endregion
-
-    #region Engine Events
-    private delegate void OnExceptionEventDelegate(object sender, ExceptionEventArgs e);
-    private void Engine_ExceptionOccurred(object sender, ExceptionEventArgs e) {
-      if (InvokeRequired)
-        Invoke(new OnExceptionEventDelegate(Engine_ExceptionOccurred), sender, e);
-      else
-        Auxiliary.ShowErrorMessageBox(e.Exception);
-    }
-    private void Engine_Finished(object sender, EventArgs e) {
-      if(InvokeRequired)
-        Invoke((EventHandler)Engine_Finished, sender, e);
-      else {
-        scopeView.Refresh();
-        executeButton.Enabled = true;
-        abortButton.Enabled = false;
-        resetButton.Enabled = true;
-      }
-    }
-    #endregion
-
-    private void setRandomSeedRandomlyCheckBox_CheckedChanged(object sender, EventArgs e) {
-      randomSeedTextBox.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
-      randomSeedLabel.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
-    }
-  }
-}
Index: unk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.resx
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.resx	(revision 2340)
+++ 	(revision )
@@ -1,120 +1,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
Index: /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegression.cs	(revision 2340)
+++ /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegression.cs	(revision 2341)
@@ -125,5 +125,4 @@
       injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000)));
       injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData(false)));
 
       return injector;
Index: /trunk/sources/HeuristicLab.sln
===================================================================
--- /trunk/sources/HeuristicLab.sln	(revision 2340)
+++ /trunk/sources/HeuristicLab.sln	(revision 2341)
@@ -251,4 +251,6 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Common-3.2", "HeuristicLab.Common\3.2\HeuristicLab.Common-3.2.csproj", "{1FC004FC-59AF-4249-B1B6-FF25873A20E4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.GP.Algorithms-3.2", "HeuristicLab.GP.Algorithms\3.2\HeuristicLab.GP.Algorithms-3.2.csproj", "{3127719F-110E-4558-8845-98559DBB422D}"
 EndProject
 Global
@@ -4025,4 +4027,32 @@
 		{1FC004FC-59AF-4249-B1B6-FF25873A20E4}.Visualization Debug|x86.ActiveCfg = Debug|x86
 		{1FC004FC-59AF-4249-B1B6-FF25873A20E4}.Visualization Debug|x86.Build.0 = Debug|x86
+		{3127719F-110E-4558-8845-98559DBB422D}.CEDMA Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.CEDMA Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.CEDMA Debug|x64.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.CEDMA Debug|x86.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Debug|x64.ActiveCfg = Debug|x64
+		{3127719F-110E-4558-8845-98559DBB422D}.Debug|x64.Build.0 = Debug|x64
+		{3127719F-110E-4558-8845-98559DBB422D}.Debug|x86.ActiveCfg = Debug|x86
+		{3127719F-110E-4558-8845-98559DBB422D}.Debug|x86.Build.0 = Debug|x86
+		{3127719F-110E-4558-8845-98559DBB422D}.Modeling Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Modeling Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Modeling Debug|x64.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Modeling Debug|x86.ActiveCfg = Debug|x86
+		{3127719F-110E-4558-8845-98559DBB422D}.Modeling Debug|x86.Build.0 = Debug|x86
+		{3127719F-110E-4558-8845-98559DBB422D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Release|x64.ActiveCfg = Release|x64
+		{3127719F-110E-4558-8845-98559DBB422D}.Release|x86.ActiveCfg = Release|x86
+		{3127719F-110E-4558-8845-98559DBB422D}.Release|x86.Build.0 = Release|x86
+		{3127719F-110E-4558-8845-98559DBB422D}.v3.2 Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.v3.2 Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.v3.2 Debug|x64.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.v3.2 Debug|x86.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Visualization Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Visualization Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Visualization Debug|x64.ActiveCfg = Debug|Any CPU
+		{3127719F-110E-4558-8845-98559DBB422D}.Visualization Debug|x86.ActiveCfg = Debug|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
@@ -4119,4 +4149,5 @@
 		{1263BB36-1F20-4960-A5CB-530746DBAD77} = {410732DB-725A-4824-896B-C298978343C0}
 		{1FC004FC-59AF-4249-B1B6-FF25873A20E4} = {410732DB-725A-4824-896B-C298978343C0}
+		{3127719F-110E-4558-8845-98559DBB422D} = {410732DB-725A-4824-896B-C298978343C0}
 		{A9E282EA-180F-4233-B809-AEDF0787545C} = {78982D7C-D63D-4A3D-AE1F-F58AC007603B}
 		{BF7D9494-A586-457B-8DF9-ED599F9E6A71} = {78982D7C-D63D-4A3D-AE1F-F58AC007603B}
