Index: /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ConsecutiveSamplesEvaluator.cs
===================================================================
--- /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ConsecutiveSamplesEvaluator.cs	(revision 10178)
+++ /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ConsecutiveSamplesEvaluator.cs	(revision 10178)
@@ -0,0 +1,164 @@
+﻿#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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.Symbolic {
+  [StorableClass]
+  public sealed class ConsecutiveSamplesEvaluator : SingleSuccessorOperator, IIterationBasedOperator, ISymbolicDataAnalysisIslandGeneticAlgorithmEvaluator {
+    private const string ProblemDataParameterName = "ProblemData";
+    private const string EvaluatorParameterName = "ProblemEvaluator";
+    private const string QualityParameterName = "Quality";
+    private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
+    private const string FixedSamplesPartitionParameterName = "FixedSamplesPartition";
+    private const string ConsecutiveSamplesParameterName = "ConsecutiveSamples";
+    private const string OverlapParameterName = "Overlap";
+    private const string DataMigrationIntervalParameterName = "DataMigrationInterval";
+    private const string IslandIndexParameterName = "IslandIndex";
+    private const string IterationsParameterName = "Iterations";
+    private const string MaximumIterationsParameterName = "Maximum Iterations";
+
+
+    #region parameter properties
+    public ILookupParameter<IDataAnalysisProblemData> ProblemDataParameter {
+      get { return (ILookupParameter<IDataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    }
+    public ILookupParameter<IOperator> EvaluatorParameter {
+      get { return (ILookupParameter<IOperator>)Parameters[EvaluatorParameterName]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
+    }
+    public ILookupParameter<IntRange> FitnessCalculationPartitionParameter {
+      get { return (IValueLookupParameter<IntRange>)Parameters[FitnessCalculationPartitionParameterName]; }
+    }
+    public ILookupParameter<IntRange> FixedSamplesPartitionParameter {
+      get { return (ILookupParameter<IntRange>)Parameters[FixedSamplesPartitionParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> ConsecutiveSamplesParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[ConsecutiveSamplesParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> OverlapParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[OverlapParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> DataMigrationIntervalParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[DataMigrationIntervalParameterName]; }
+    }
+    public ILookupParameter<IntValue> IslandIndexParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[IslandIndexParameterName]; }
+    }
+    public ILookupParameter<IntValue> IterationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[IterationsParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumIterationsParameterName]; }
+    }
+
+    #endregion
+
+    #region properties
+
+    public int ConsecutiveSamples {
+      get { return ConsecutiveSamplesParameter.Value.Value; }
+      set { ConsecutiveSamplesParameter.Value.Value = value; }
+    }
+
+    public int Overlap {
+      get { return OverlapParameter.Value.Value; }
+      set { OverlapParameter.Value.Value = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private ConsecutiveSamplesEvaluator(bool deserializing) : base(deserializing) { }
+    private ConsecutiveSamplesEvaluator(ConsecutiveSamplesEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConsecutiveSamplesEvaluator(this, cloner);
+    }
+
+    public ConsecutiveSamplesEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<IDataAnalysisProblemData>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
+      Parameters.Add(new LookupParameter<IOperator>(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 LookupParameter<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 FixedValueParameter<IntValue>(ConsecutiveSamplesParameterName, "The number of consecutive samples used for fitness calculation in each island.", new IntValue()));
+      Parameters.Add(new FixedValueParameter<IntValue>(OverlapParameterName, "The overlap for the consecutive samples used for every island.", new IntValue()));
+      Parameters.Add(new ValueLookupParameter<IntValue>(DataMigrationIntervalParameterName, "The number of generations that should pass between data migration phases."));
+      Parameters.Add(new LookupParameter<IntValue>(IslandIndexParameterName, "The index of the current island."));
+      Parameters.Add(new LookupParameter<IntValue>(IterationsParameterName, "The number of performed iterations."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsParameterName, "The maximum number of performed iterations.") { Hidden = true });
+    }
+
+    public override IOperation Apply() {
+      var evaluator = EvaluatorParameter.ActualValue;
+      var problemData = ProblemDataParameter.ActualValue;
+      var samples = FitnessCalculationPartitionParameter.ActualValue;
+      var fixedSamples = FixedSamplesPartitionParameter.ActualValue;
+
+      //create fixed rows enumerable
+      var rows = Enumerable.Range(fixedSamples.Start, fixedSamples.Size);
+      //create consecutive rows enumerable
+      if (ConsecutiveSamples > 0) {
+        var dataMigrationInterval = DataMigrationIntervalParameter.ActualValue.Value;
+        var islandIndex = IslandIndexParameter.ActualValue.Value;
+        var generation = IterationsParameter.ActualValue.Value;
+        var iteration = islandIndex + (generation / dataMigrationInterval);
+        var consecutiveRows = GenerateRows(samples, fixedSamples, ConsecutiveSamples, Overlap, iteration);
+        rows = rows.Concat(consecutiveRows);
+      }
+      //filter out test rows
+      rows = rows.Where(r => r < problemData.TestPartition.Start || r > problemData.TestPartition.End);
+
+      //execution context is created manually to be able to clear the rows parameter easily
+      var executionContext = new ExecutionContext(ExecutionContext, evaluator, ExecutionContext.Scope);
+
+      //TODO change to lookup parameter
+      executionContext.Scope.Variables.Remove("Rows");
+      executionContext.Scope.Variables.Add(new HeuristicLab.Core.Variable("Rows", new EnumerableItem<int>(rows)));
+      var successor = evaluator.Execute(executionContext, this.CancellationToken);
+      return new OperationCollection(successor, base.Apply());
+    }
+
+    public static IEnumerable<int> GenerateRows(IntRange samples, IntRange fixedSamples, int consecutiveSamples, int overlap, int iteration) {
+      var consecutiveSamplesStart = (consecutiveSamples - overlap) * iteration;
+      consecutiveSamplesStart = consecutiveSamplesStart % (samples.Size - fixedSamples.Size);
+      var rows = Enumerable.Range(fixedSamples.End, samples.End - fixedSamples.End);
+      rows = rows.Concat(Enumerable.Range(samples.Start, fixedSamples.Start - samples.Start));
+      rows = rows.Concat(Enumerable.Range(fixedSamples.End, samples.End - fixedSamples.End));
+      rows = rows.Concat(Enumerable.Range(samples.Start, fixedSamples.Start - samples.Start));
+      return rows.Skip(consecutiveSamplesStart).Take(consecutiveSamples);
+    }
+  }
+}
Index: /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Tests/ConsecutiveSamplesEvaluatorTest.cs
===================================================================
--- /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Tests/ConsecutiveSamplesEvaluatorTest.cs	(revision 10178)
+++ /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Tests/ConsecutiveSamplesEvaluatorTest.cs	(revision 10178)
@@ -0,0 +1,121 @@
+﻿using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Algorithms.DataAnalysis.Symbolic;
+using HeuristicLab.Data;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace HeuristicLab.Tests {
+  [TestClass]
+  public class ConsecutiveSamplesEvaluatorTest {
+    [TestMethod]
+    public void GenerateRowsTest() {
+
+      IntRange samples = new IntRange(0, 50);
+      IntRange fixedSamples = new IntRange(0, 30);
+      IEnumerable<int> rows = null;
+
+      //test simple case
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 0);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(30, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 1);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(40, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 2);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(30, 10)));
+
+      for (int i = 0; i < 10; i++) {
+        rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: i);
+        var match = Enumerable.Range(30 + i % 2 * 10, 10);
+        Assert.IsTrue(rows.SequenceEqual(match));
+      }
+
+      //test with overlap
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 5, iteration: 0);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(30, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 5, iteration: 1);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(35, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 5, iteration: 2);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(40, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 5, iteration: 3);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(45, 5).Concat(Enumerable.Range(30, 5))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 5, iteration: 4);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(30, 10)));
+
+      //test with overlap
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 7, iteration: 0);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(30, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 7, iteration: 1);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(33, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 7, iteration: 2);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(36, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 7, iteration: 3);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(39, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 7, iteration: 4);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(42, 8).Concat(Enumerable.Range(30, 2))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 7, iteration: 5);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(45, 5).Concat(Enumerable.Range(30, 5))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 7, iteration: 6);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(48, 2).Concat(Enumerable.Range(30, 8))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 7, iteration: 7);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(31, 10)));
+
+
+      samples = new IntRange(0, 60);
+      fixedSamples = new IntRange(20, 40);
+
+      //test simple case
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 0);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(40, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 1);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(50, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 2);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(0, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 3);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(10, 10)));
+
+      //test with overlap
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 30, overlap: 25, iteration: 0);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(40, 20).Concat(Enumerable.Range(0, 10))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 30, overlap: 25, iteration: 1);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(45, 15).Concat(Enumerable.Range(0, 15))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 30, overlap: 25, iteration: 2);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(50, 10).Concat(Enumerable.Range(0, 20))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 30, overlap: 25, iteration: 3);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(55, 5).Concat(Enumerable.Range(0, 20).Concat(Enumerable.Range(40, 5)))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 30, overlap: 25, iteration: 4);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(0, 20).Concat(Enumerable.Range(40, 10))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 30, overlap: 25, iteration: 5);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(5, 15).Concat(Enumerable.Range(40, 15))));
+
+      samples = new IntRange(10, 60);
+      fixedSamples = new IntRange(20, 40);
+      //test simple case
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 0);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(40, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 1);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(50, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 2);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(10, 10)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 10, overlap: 0, iteration: 3);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(40, 10)));
+
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 20, overlap: 15, iteration: 0);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(40, 20)));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 20, overlap: 15, iteration: 1);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(45, 15).Concat(Enumerable.Range(10, 5))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 20, overlap: 15, iteration: 2);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(50, 10).Concat(Enumerable.Range(10, 10))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 20, overlap: 15, iteration: 3);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(55, 5).Concat(Enumerable.Range(10, 10).Concat(Enumerable.Range(40, 5)))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 20, overlap: 15, iteration: 4);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(10, 10).Concat(Enumerable.Range(40, 10))));
+      rows = ConsecutiveSamplesEvaluator.GenerateRows(samples, fixedSamples, consecutiveSamples: 20, overlap: 15, iteration: 5);
+      Assert.IsTrue(rows.SequenceEqual(Enumerable.Range(15, 5).Concat(Enumerable.Range(40, 15))));
+
+
+      //error cases
+      //consecutive samples larger than remaining samples
+      //fixed samples partition invalid
+    }
+  }
+}
Index: /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 10178)
+++ /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 10178)
@@ -0,0 +1,119 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{F26EC1D3-4338-4F8B-AE5C-434D9256D580}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Tests</RootNamespace>
+    <AssemblyName>HeuristicLab.Tests</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages</ReferencePath>
+    <IsCodedUITest>False</IsCodedUITest>
+    <TestProjectType>UnitTest</TestProjectType>
+  </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>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.Analysis-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Optimization.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Persistence-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Selection-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+  </ItemGroup>
+  <Choose>
+    <When Condition="('$(VisualStudioVersion)' == '10.0' or '$(VisualStudioVersion)' == '') and '$(TargetFrameworkVersion)' == 'v3.5'">
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+      </ItemGroup>
+    </When>
+    <Otherwise>
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework" />
+      </ItemGroup>
+    </Otherwise>
+  </Choose>
+  <ItemGroup>
+    <Compile Include="ConsecutiveSamplesEvaluatorTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\HeuristicLab.Algorithms.DataAnalysis.Symbolic\3.3\HeuristicLab.Algorithms.DataAnalysis.Symbolic.csproj">
+      <Project>{f0d5af15-76a8-4023-ab77-7b138d579860}</Project>
+      <Name>HeuristicLab.Algorithms.DataAnalysis.Symbolic</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\HeuristicLab.Algorithms.GeneticAlgorithm\3.3\HeuristicLab.Algorithms.GeneticAlgorithm-3.3.csproj">
+      <Project>{A51DA44F-CB35-4F6F-99F5-2A2E904AB93B}</Project>
+      <Name>HeuristicLab.Algorithms.GeneticAlgorithm-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm\3.3\HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm-3.3.csproj">
+      <Project>{F409DD9E-1E9C-4EB1-AA3A-9F6E987C6E58}</Project>
+      <Name>HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\HeuristicLab.Problems.DataAnalysis.Symbolic\3.4\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj">
+      <Project>{3D28463F-EC96-4D82-AFEE-38BE91A0CA00}</Project>
+      <Name>HeuristicLab.Problems.DataAnalysis.Symbolic-3.4</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Choose>
+    <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.CodedUITestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Common, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Extension, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITesting, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+      </ItemGroup>
+    </When>
+  </Choose>
+  <Import Project="$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets" Condition="Exists('$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets')" />
+  <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>
+  -->
+</Project>
Index: /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Tests/Properties/AssemblyInfo.cs
===================================================================
--- /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Tests/Properties/AssemblyInfo.cs	(revision 10178)
+++ /branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Tests/Properties/AssemblyInfo.cs	(revision 10178)
@@ -0,0 +1,36 @@
+﻿using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab.Tests")]
+[assembly: AssemblyCopyright("Copyright ©  2013")]
+[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("a73b86bc-4c38-4a7f-9290-cf031160d057")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
