Index: branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/HeuristicLab.Algorithms.DataAnalysis.Symbolic.csproj
===================================================================
--- branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/HeuristicLab.Algorithms.DataAnalysis.Symbolic.csproj	(revision 9074)
+++ branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/HeuristicLab.Algorithms.DataAnalysis.Symbolic.csproj	(revision 9077)
@@ -109,4 +109,6 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ISymbolicDataAnalysisIslandGAEvaluator .cs" />
+    <Compile Include="ScopeTreeAssigner.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
Index: branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ISymbolicDataAnalysisIslandGAEvaluator .cs
===================================================================
--- branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ISymbolicDataAnalysisIslandGAEvaluator .cs	(revision 9077)
+++ branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ISymbolicDataAnalysisIslandGAEvaluator .cs	(revision 9077)
@@ -0,0 +1,27 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.Symbolic {
+  public interface ISymbolicDataAnalysisIslandGAEvaluator : ISingleObjectiveEvaluator {
+  }
+}
Index: branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ScopeTreeAssigner.cs
===================================================================
--- branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ScopeTreeAssigner.cs	(revision 9077)
+++ branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ScopeTreeAssigner.cs	(revision 9077)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.Symbolic {
+  /// <summary>
+  /// An operator which clones and assigns the value of one parameter to another parameter.
+  /// </summary>
+  [Item("ScopeTreeAssigner", "An operator which clones and assigns the value of one parameter to another parameter.")]
+  [StorableClass]
+  public sealed class ScopeTreeAssigner<T> : SingleSuccessorOperator where T : class, IItem {
+    public ScopeTreeLookupParameter<T> LeftSideParameter {
+      get { return (ScopeTreeLookupParameter<T>)Parameters["LeftSide"]; }
+    }
+    public IValueLookupParameter<ItemArray<T>> RightSideParameter {
+      get { return (IValueLookupParameter<ItemArray<T>>)Parameters["RightSide"]; }
+    }
+
+    [StorableConstructor]
+    private ScopeTreeAssigner(bool deserializing) : base(deserializing) { }
+    private ScopeTreeAssigner(ScopeTreeAssigner<T> original, Cloner cloner) : base(original, cloner) { }
+
+    public ScopeTreeAssigner()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<T>("LeftSide", "The parameter whose value gets assigned with a clone of the other parameter's value."));
+      Parameters.Add(new ValueLookupParameter<ItemArray<T>>("RightSide", "The parameter whose value is cloned and assigned to the value of the other parameter."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ScopeTreeAssigner<T>(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      LeftSideParameter.ActualValue = (ItemArray<T>)RightSideParameter.ActualValue.Clone();
+      return base.Apply();
+    }
+  }
+}
Index: branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/SymbolicDataAnalysisIslandGAEvaluator.cs
===================================================================
--- branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/SymbolicDataAnalysisIslandGAEvaluator.cs	(revision 9074)
+++ branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/SymbolicDataAnalysisIslandGAEvaluator.cs	(revision 9077)
@@ -20,26 +20,32 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.Symbolic {
   [StorableClass]
-  public sealed class SymbolicDataAnalysisIslandGAEvaluator<T> : SingleSuccessorOperator, IStochasticOperator
+  public sealed class SymbolicDataAnalysisIslandGAEvaluator<T> : SingleSuccessorOperator, IStochasticOperator, ISymbolicDataAnalysisIslandGAEvaluator
     where T : class,IDataAnalysisProblemData {
     private const string RandomParameterName = "Random";
-    private const string EvaluatorParameterName = "Evaluator";
-    private const string IslandNumberParameterName = "IslandNumber";
-    private const string NumberOfIslandsParameterName = "NumberOfIslands";
-    private const string ConstantSamplesParameterName = "ConstantSamples";
-    private const string ConstantSamplesFitnessWeightFactorParameterName = "ConstantSamplesFitnessWeight";
+    private const string ProblemDataParameterName = "ProblemData";
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string EvaluatorParameterName = "ProblemEvaluator";
+    private const string QualityParameterName = "Quality";
+    private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
+    private const string FixedSamplesPartitionParameterName = "FixedSamplesPartition";
+    private const string FixedSamplesParameterName = "FixedSamples";
+    private const string FixedSamplesFitnessWeightParameterName = "FixedSamplesFitnessWeight";
     private const string RandomSamplesParameterName = "RandomSamples";
     private const string RandomSamplesFitnessWeightParameterName = "RandomSamplesFitnessWeight";
-    private const string RandomSamplesConsecutiveParameterName = "RandomSamplesConsecutive";
 
     #region parameter properties
@@ -47,52 +53,44 @@
       get { return (ILookupParameter<IRandom>)Parameters[RandomParameterName]; }
     }
-    public IValueParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>> EvaluatorParameter {
-      get { return (IValueParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>)Parameters[EvaluatorParameterName]; }
+    public ILookupParameter<T> ProblemDataParameter {
+      get { return (ILookupParameter<T>)Parameters[ProblemDataParameterName]; }
     }
-
-    public ILookupParameter<IntValue> NumberOfIslandParameter {
-      get { return (ILookupParameter<IntValue>)Parameters[NumberOfIslandsParameterName]; }
+    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
     }
-    public IFixedValueParameter<IntValue> ConstantSamplesParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantSamplesParameterName]; }
+    public ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>> EvaluatorParameter {
+      get { return (ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>)Parameters[EvaluatorParameterName]; }
     }
-    public IFixedValueParameter<DoubleValue> ConstantSamplesFitnessWeightParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[ConstantSamplesFitnessWeightFactorParameterName]; }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
     }
-    public IFixedValueParameter<IntValue> RandomSamplesParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[RandomSamplesParameterName]; }
+    public IValueLookupParameter<IntRange> FitnessCalculationPartitionParameter {
+      get { return (IValueLookupParameter<IntRange>)Parameters[FitnessCalculationPartitionParameterName]; }
+    }
+    public ILookupParameter<IntRange> FixedSamplesPartitionParameter {
+      get { return (ILookupParameter<IntRange>)Parameters[FixedSamplesPartitionParameterName]; }
+    }
+    public ILookupParameter<IntValue> FixedSamplesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[FixedSamplesParameterName]; }
+    }
+    public IFixedValueParameter<DoubleValue> FixedSamplesFitnessWeightParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[FixedSamplesFitnessWeightParameterName]; }
+    }
+    public ILookupParameter<IntValue> RandomSamplesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[RandomSamplesParameterName]; }
     }
     public IFixedValueParameter<DoubleValue> RandomSamplesFitnessWeightParameter {
       get { return (IFixedValueParameter<DoubleValue>)Parameters[RandomSamplesFitnessWeightParameterName]; }
     }
-    public IFixedValueParameter<BoolValue> RandomSamplesConsecutiveParameter {
-      get { return (IFixedValueParameter<BoolValue>)Parameters[RandomSamplesConsecutiveParameterName]; }
-    }
     #endregion
 
     #region properties
-    public ISymbolicDataAnalysisSingleObjectiveEvaluator<T> Evaluator {
-      get { return EvaluatorParameter.Value; }
-      set { EvaluatorParameter.Value = value; }
-    }
-    public int ConstantSamples {
-      get { return ConstantSamplesParameter.Value.Value; }
-      set { ConstantSamplesParameter.Value.Value = value; }
-    }
-    public double ConstantSamplesFitnessWeight {
-      get { return ConstantSamplesFitnessWeightParameter.Value.Value; }
-      set { ConstantSamplesFitnessWeightParameter.Value.Value = value; }
-    }
-    public int RandomSamples {
-      get { return RandomSamplesParameter.Value.Value; }
-      set { RandomSamplesParameter.Value.Value = value; }
+    public double FixedSamplesFitnessWeight {
+      get { return FixedSamplesFitnessWeightParameter.Value.Value; }
+      set { FixedSamplesFitnessWeightParameter.Value.Value = value; }
     }
     public double RandomSamplesFitnessWeight {
       get { return RandomSamplesFitnessWeightParameter.Value.Value; }
       set { RandomSamplesFitnessWeightParameter.Value.Value = value; }
-    }
-    public bool RandomSamplesConsecutive {
-      get { return RandomSamplesConsecutiveParameter.Value.Value; }
-      set { RandomSamplesConsecutiveParameter.Value.Value = value; }
     }
     #endregion
@@ -109,5 +107,45 @@
     public SymbolicDataAnalysisIslandGAEvaluator()
       : base() {
+      Parameters.Add(new LookupParameter<IRandom>(RandomParameterName, "The random generator to use."));
+      Parameters.Add(new LookupParameter<T>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic data analysis solution encoded as a symbolic expression tree."));
+      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>(EvaluatorParameterName, "The evaluator provided by the symbolic data analysis  problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName, "The quality which is calculated by the encapsulated evaluator."));
+      Parameters.Add(new ValueLookupParameter<IntRange>(FitnessCalculationPartitionParameterName, "The data partition used to calculate the fitness"));
+      Parameters.Add(new LookupParameter<IntRange>(FixedSamplesPartitionParameterName, "The data partition which is used to calculate the fitness on the fixed samples."));
+      Parameters.Add(new LookupParameter<IntValue>(FixedSamplesParameterName, "The number of fixed samples used for fitness calculation in each island."));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(FixedSamplesFitnessWeightParameterName, "The weight of the fitness obtained on the fixed samples.", new DoubleValue(1)));
+      Parameters.Add(new LookupParameter<IntValue>(RandomSamplesParameterName, "The number of random samples used for fitness calculation in each island."));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(RandomSamplesFitnessWeightParameterName, "The weight of the fitness obtained on the random samples.", new DoubleValue(1)));
 
+      EvaluatorParameter.Hidden = true;
+    }
+
+    public override IOperation Apply() {
+      var evaluator = EvaluatorParameter.ActualValue;
+      //calculate fitness on fixed samples
+      if (QualityParameter.ActualValue == null) {
+        var operation = ExecutionContext.CreateOperation(evaluator, ExecutionContext.Scope);
+        return new OperationCollection() { operation, ExecutionContext.CreateOperation(this) };
+      }
+      //calculate fitness on random samples;
+      var samplesStart = FitnessCalculationPartitionParameter.ActualValue.Start;
+      var samplesEnd = FitnessCalculationPartitionParameter.ActualValue.End;
+      var fixedSamplesStart = FixedSamplesPartitionParameter.ActualValue.Start;
+      var fixedSamplesEnd = FixedSamplesPartitionParameter.ActualValue.End;
+      var randomSamples = RandomSamplesParameter.ActualValue.Value;
+      var maxRandomSamples = samplesEnd - samplesStart - fixedSamplesEnd + fixedSamplesStart;
+
+      var rows = Enumerable.Range(samplesStart, samplesEnd - samplesStart).Where(r => r < fixedSamplesStart || r >= fixedSamplesEnd);
+      rows = rows.SampleRandomWithoutRepetition(RandomParameter.ActualValue, randomSamples, maxRandomSamples);
+
+      var fixedSamplesFitness = QualityParameter.ActualValue.Value;
+      var tree = SymbolicExpressionTreeParameter.ActualValue;
+      var problemData = ProblemDataParameter.ActualValue;
+
+      var executionContext = new ExecutionContext(ExecutionContext, evaluator, ExecutionContext.Scope);
+      var randomSamplesFitness = evaluator.Evaluate(executionContext, tree, problemData, rows);
+      QualityParameter.ActualValue.Value = fixedSamplesFitness * FixedSamplesFitnessWeight + randomSamplesFitness * RandomSamplesFitnessWeight;
+      return base.Apply();
     }
   }
Index: branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/SymbolicDataAnalysisIslandGeneticAlgorithm.cs
===================================================================
--- branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/SymbolicDataAnalysisIslandGeneticAlgorithm.cs	(revision 9074)
+++ branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/SymbolicDataAnalysisIslandGeneticAlgorithm.cs	(revision 9077)
@@ -27,7 +27,10 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.Symbolic {
@@ -37,6 +40,9 @@
   public sealed class SymbolicDataAnalysisIslandGeneticAlgorithm : IslandGeneticAlgorithm {
     private const string FixedSamplesParameterName = "NumberOfFixedSamples";
+    private const string FixedSamplesPartitionParameterName = "FixedSamplesPartition";
     private const string FixedSamplesPartitionsParameterName = "FixedSamplesPartitions";
     private const string RandomSamplesParameterName = "NumberOfRandomSamples";
+    private const string EvaluatorParameterName = "IslandEvaluator";
+    private const string ProblemEvaluatorParameterName = "ProblemEvaluator";
 
     #region Problem Properties
@@ -59,4 +65,10 @@
     public IFixedValueParameter<IntValue> RandomSamplesParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[RandomSamplesParameterName]; }
+    }
+    public IValueParameter<ISymbolicDataAnalysisIslandGAEvaluator> EvaluatorParameter {
+      get { return (IValueParameter<ISymbolicDataAnalysisIslandGAEvaluator>)Parameters[EvaluatorParameterName]; }
+    }
+    private ILookupParameter<ISingleObjectiveEvaluator> ProblemEvaluatorParameter {
+      get { return (ILookupParameter<ISingleObjectiveEvaluator>)Parameters[ProblemEvaluatorParameterName]; }
     }
     #endregion
@@ -95,8 +107,45 @@
       Parameters.Add(new FixedValueParameter<IntValue>(FixedSamplesParameterName, "The number of fixed samples used for fitness calculation in each island.", new IntValue(0)));
       Parameters.Add(new ValueParameter<ItemArray<IntRange>>(FixedSamplesPartitionsParameterName, "The fixed samples partitions used for fitness calculation for every island."));
-      Parameters.Add(new FixedValueParameter<IntValue>(RandomSamplesParameterName, "The number of random samples used for fitness calculation in each island..", new IntValue(0)));
+      Parameters.Add(new FixedValueParameter<IntValue>(RandomSamplesParameterName, "The number of random samples used for fitness calculation in each island.", new IntValue(0)));
+      Parameters.Add(new OptionalValueParameter<ISymbolicDataAnalysisIslandGAEvaluator>(EvaluatorParameterName, "The evaluator of the algorithm."));
+      Parameters.Add(new LookupParameter<ISingleObjectiveEvaluator>(ProblemEvaluatorParameterName, "Internal parameter for name translation", "Evaluator"));
+
+      ScopeTreeAssigner<IntRange> fixedSamplesPartitionCreator = new ScopeTreeAssigner<IntRange>();
+      fixedSamplesPartitionCreator.LeftSideParameter.ActualName = FixedSamplesPartitionParameterName;
+      fixedSamplesPartitionCreator.RightSideParameter.ActualName = FixedSamplesPartitionsParameterName;
+
+      RandomCreator insertionPoint = OperatorGraph.Iterate().OfType<RandomCreator>().Skip(1).First();
+      fixedSamplesPartitionCreator.Successor = insertionPoint.Successor;
+      insertionPoint.Successor = fixedSamplesPartitionCreator;
 
       RegisterParameterEvents();
       RecalculateFixedSamplesPartitions();
+    }
+
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      ParameterizeProblemEvaluator();
+      base.Problem_EvaluatorChanged(sender, e);
+    }
+
+    private void ParameterizeProblemEvaluator() {
+      var regresssionEvaluator = Problem.Evaluator as ISymbolicDataAnalysisEvaluator<IRegressionProblemData>;
+      if (regresssionEvaluator != null) {
+        regresssionEvaluator.EvaluationPartitionParameter.ActualName = FixedSamplesPartitionParameterName;
+      }
+      var classificationEvaluator = Problem.Evaluator as ISymbolicDataAnalysisEvaluator<IClassificationProblemData>;
+      if (classificationEvaluator != null) {
+        classificationEvaluator.EvaluationPartitionParameter.ActualName = FixedSamplesPartitionParameterName;
+      }
+    }
+
+    protected override void ParameterizeSolutionsCreator() {
+      base.ParameterizeSolutionsCreator();
+      SolutionsCreator.EvaluatorParameter.ActualName = EvaluatorParameterName;
+    }
+
+    protected override void ParameterizeMainLoop() {
+      base.ParameterizeMainLoop();
+      MainLoop.EvaluatorParameter.ActualName = EvaluatorParameterName;
+      MainLoop.QualityParameter.ActualName = EvaluatorParameter.Value.QualityParameter.ActualName;
     }
 
@@ -114,11 +163,29 @@
     protected override void Problem_Reset(object sender, EventArgs e) {
       RecalculateFixedSamplesPartitions();
+      ParameterizeProblemEvaluator();
       base.Problem_Reset(sender, e);
     }
 
     protected override void OnProblemChanged() {
+      Problem.FitnessCalculationPartition.ValueChanged += (o, e) => RecalculateFixedSamplesPartitions();
+
+      ParameterizeProblemEvaluator();
+      if (Problem is IRegressionProblem) {
+        var evaluator = new SymbolicDataAnalysisIslandGAEvaluator<IRegressionProblemData>();
+        evaluator.FixedSamplesParameter.ActualName = FixedSamplesParameterName;
+        evaluator.RandomSamplesParameter.ActualName = RandomSamplesParameterName;
+        EvaluatorParameter.Value = evaluator;
+      } else if (Problem is IClassificationProblem) {
+        var evaluator = new SymbolicDataAnalysisIslandGAEvaluator<IClassificationProblemData>();
+        evaluator.FixedSamplesParameter.ActualName = FixedSamplesParameterName;
+        evaluator.RandomSamplesParameter.ActualName = RandomSamplesParameterName;
+        EvaluatorParameter.Value = evaluator;
+      } else
+        EvaluatorParameter.Value = null;
+
+      ParameterizeStochasticOperatorForIsland(EvaluatorParameter.Value);
+
+      RecalculateFixedSamplesPartitions();
       base.OnProblemChanged();
-      Problem.FitnessCalculationPartition.ValueChanged += (o, e) => RecalculateFixedSamplesPartitions();
-      RecalculateFixedSamplesPartitions();
     }
 
Index: branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/IslandGeneticAlgorithm.cs
===================================================================
--- branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/IslandGeneticAlgorithm.cs	(revision 9074)
+++ branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/IslandGeneticAlgorithm.cs	(revision 9077)
@@ -177,14 +177,14 @@
       set { IslandAnalyzerParameter.Value = value; }
     }
-    private RandomCreator RandomCreator {
+    protected RandomCreator RandomCreator {
       get { return (RandomCreator)OperatorGraph.InitialOperator; }
     }
-    private UniformSubScopesProcessor IslandProcessor {
+    protected UniformSubScopesProcessor IslandProcessor {
       get { return OperatorGraph.Iterate().OfType<UniformSubScopesProcessor>().First(x => x.Operator is SolutionsCreator); }
     }
-    private SolutionsCreator SolutionsCreator {
+    protected SolutionsCreator SolutionsCreator {
       get { return (SolutionsCreator)IslandProcessor.Operator; }
     }
-    private IslandGeneticAlgorithmMainLoop MainLoop {
+    protected IslandGeneticAlgorithmMainLoop MainLoop {
       get { return FindMainLoop(IslandProcessor.Successor); }
     }
@@ -417,9 +417,9 @@
       }
     }
-    private void ParameterizeSolutionsCreator() {
+    protected virtual void ParameterizeSolutionsCreator() {
       SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
       SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
     }
-    private void ParameterizeMainLoop() {
+    protected virtual void ParameterizeMainLoop() {
       MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
       MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
@@ -427,5 +427,5 @@
       MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
     }
-    private void ParameterizeStochasticOperator(IOperator op) {
+    protected void ParameterizeStochasticOperator(IOperator op) {
       IStochasticOperator stochasticOp = op as IStochasticOperator;
       if (stochasticOp != null) {
@@ -434,5 +434,5 @@
       }
     }
-    private void ParameterizeStochasticOperatorForIsland(IOperator op) {
+    protected void ParameterizeStochasticOperatorForIsland(IOperator op) {
       IStochasticOperator stochasticOp = op as IStochasticOperator;
       if (stochasticOp != null) {
