Index: branches/EfficientGlobalOptimization/Build.cmd
===================================================================
--- branches/EfficientGlobalOptimization/Build.cmd	(revision 14741)
+++ branches/EfficientGlobalOptimization/Build.cmd	(revision 14741)
@@ -0,0 +1,104 @@
+@ECHO OFF
+
+SET CLEANBEFOREBUILD=
+
+SET SELECTED=
+SET CONFIGURATION=
+SET PLATFORM=
+
+IF "%~1"=="" GOTO :prompt_solution
+
+SET SELECTED=%1
+IF NOT EXIST %SELECTED% (
+  ECHO Solution file %SELECTED% could not be found.
+  GOTO :end
+)
+ECHO Building solution %SELECTED% ...
+GOTO :config_selection
+
+:prompt_solution
+SET /A COUNT=0
+FOR /F "tokens=*" %%A IN ('dir /B *.sln') DO (
+  CALL :forloopbody "%%A"
+)
+
+IF "%COUNT%"=="1" (
+  SET SELECTED=%SOLUTIONS.1%
+  ECHO Building %SOLUTIONS.1% as it is the only solution that was found ...
+  GOTO :config_selection
+)
+
+ECHO Found the following solutions:
+FOR /F "tokens=2* delims=.=" %%A IN ('SET SOLUTIONS.') DO ECHO %%A = %%B
+ECHO.
+SET /P SOLUTIONINDEX=Which solution to build? Type the number: 
+
+SET SELECTED=""
+FOR /F "tokens=2* delims=.=" %%A IN ('SET SOLUTIONS.') DO (
+  IF "%%A"=="%SOLUTIONINDEX%" SET SELECTED=%%B
+)
+
+IF %SELECTED%=="" GOTO :eof
+
+:config_selection
+IF "%~2"==""  GOTO :prompt_config
+
+SET CONFIGURATION=%~2
+ECHO Building configuration %CONFIGURATION% ...
+GOTO :platform_selection
+
+:prompt_config
+SET /P CONFIGURATION=Which configuration to build [Release]: 
+IF "%CONFIGURATION%"=="" SET CONFIGURATION=Release
+
+:platform_selection
+IF "%~3"=="" GOTO :prompt_platform
+  
+SET PLATFORM=%~3
+ECHO Building platform %PLATFORM% ...
+GOTO :clean
+
+:prompt_platform
+SET /P PLATFORM=Which platform to build [Any CPU]: 
+IF "%PLATFORM%"=="" SET PLATFORM=Any CPU
+
+:clean
+IF "%~4"=="" GOTO :prompt_clean
+
+SET CLEANBEFOREBUILD=%~4
+GOTO :main
+
+:prompt_clean
+SET /P CLEANBEFOREBUILD=Would you like to clean before building [n]: 
+IF "%CLEANBEFOREBUILD%"=="" SET CLEANBEFOREBUILD=n
+
+:main
+REM First find the path to the msbuild.exe by performing a registry query
+FOR /F "tokens=1,3 delims=	 " %%A IN ('REG QUERY "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0"') DO (
+  IF "%%A"=="MSBuildToolsPath" SET MSBUILDPATH=%%B)
+
+REM Then execute msbuild to clean and build the solution
+REM Disable that msbuild creates a cache file of the solution
+SET MSBuildUseNoSolutionCache=1
+REM Run msbuild to clean and then build
+IF "%CLEANBEFOREBUILD%" NEQ "n" (
+  ECHO Cleaning ...
+  %MSBUILDPATH%msbuild.exe %SELECTED% /target:Clean /p:Configuration="%CONFIGURATION%",Platform="%PLATFORM%" /m:2 /nologo /verbosity:q /clp:ErrorsOnly
+)
+ECHO Building ...
+%MSBUILDPATH%msbuild.exe %SELECTED% /target:Build /p:Configuration="%CONFIGURATION%",Platform="%PLATFORM%" /m:2 /nologo /verbosity:q /clp:ErrorsOnly
+
+ECHO.
+ECHO DONE.
+
+:end
+
+PAUSE
+
+GOTO :eof
+
+REM This workaround is necessary so that COUNT gets reevaluated
+:forloopbody
+SET /A COUNT+=1
+SET SOLUTIONS.%COUNT%=%1
+GOTO :eof
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO.sln
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO.sln	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO.sln	(revision 14741)
@@ -0,0 +1,22 @@
+﻿
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.EGO-3.4", "HeuristicLab.Algorithms.EGO\HeuristicLab.Algorithms.EGO-3.4.csproj", "{F740AF15-7ADA-40D9-B225-837F4E4F41E0}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F740AF15-7ADA-40D9-B225-837F4E4F41E0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F740AF15-7ADA-40D9-B225-837F4E4F41E0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F740AF15-7ADA-40D9-B225-837F4E4F41E0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F740AF15-7ADA-40D9-B225-837F4E4F41E0}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EfficientGlobalOptimizationAlgorithm.cs
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EfficientGlobalOptimizationAlgorithm.cs	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EfficientGlobalOptimizationAlgorithm.cs	(revision 14741)
@@ -0,0 +1,427 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Algorithms.CMAEvolutionStrategy;
+using HeuristicLab.Algorithms.DataAnalysis;
+using HeuristicLab.Algorithms.EGO;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.SurrogateProblem {
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.Algorithms, Priority = 95)]
+  [Item("EfficientGlobalOptimizationAlgortihm", "Solves a problem by sequentially learning a model, solving a subproblem on the model and evaluating the best found solution for this subproblem.")]
+  public class EfficientGlobalOptimizationAlgorithm : BasicAlgorithm {
+    #region Basic-Alg-Essentials
+    public override bool SupportsPause => true;
+    public override Type ProblemType => typeof(SingleObjectiveBasicProblem<IEncoding>);
+    public new SingleObjectiveBasicProblem<IEncoding> Problem
+    {
+      get { return (SingleObjectiveBasicProblem<IEncoding>)base.Problem; }
+      set { base.Problem = value; }
+    }
+    #endregion
+
+    #region ParameterNames
+    private const string GenerationSizeParameterName = "GenerationSize";
+    private const string InfillCriterionParameterName = "InfillCriterion";
+    private const string InfillOptimizationAlgorithmParameterName = "InfillOptimizationAlgorithm";
+    private const string InfillOptimizationRestartsParameterName = "InfillOptimizationRestarts";
+    private const string InitialEvaluationsParameterName = "Initial Evaluations";
+    private const string MaximumIterationsParameterName = "Maximum Iterations";
+    private const string MaximumRuntimeParameterName = "Maximum Runtime";
+    private const string RegressionAlgorithmParameterName = "RegressionAlgorithm";
+    private const string SeedParameterName = "Seed";
+    private const string SetSeedRandomlyParameterName = "SetSeedRandomly";
+    #endregion
+
+    #region ResultNames
+    private const string BestQualityResultName = "Best Quality";
+    private const string BestSolutionResultName = "Best Solution";
+    private const string EvaluatedSoultionsResultName = "EvaluatedSolutions";
+    private const string IterationsResultName = "Iterations";
+    private const string RegressionSolutionResultName = "Model";
+    private const string QualitiesChartResultName = "Qualities";
+    private const string BestQualitiesRowResultName = "Best Quality";
+    private const string CurrentQualitiesRowResultName = "Current Quality";
+    private const string WorstQualitiesRowResultName = "Worst Quality";
+    #endregion
+
+    #region TransmissionResultNames
+    public const string BestInfillSolutionResultName = "BestInfillSolution";
+    public const string BestInfillQualityResultName = "BestInfillQuality";
+    #endregion
+
+    #region ParameterProperties
+    public IFixedValueParameter<IntValue> GenerationSizeParemeter => Parameters[GenerationSizeParameterName] as IFixedValueParameter<IntValue>;
+    public IConstrainedValueParameter<IInfillCriterion> InfillCriterionParameter => Parameters[InfillCriterionParameterName] as IConstrainedValueParameter<IInfillCriterion>;
+    public IValueParameter<Algorithm> InfillOptimizationAlgorithmParameter => Parameters[InfillOptimizationAlgorithmParameterName] as IValueParameter<Algorithm>;
+    public IFixedValueParameter<IntValue> InfillOptimizationRestartsParemeter => Parameters[InfillOptimizationRestartsParameterName] as IFixedValueParameter<IntValue>;
+    public IFixedValueParameter<IntValue> InitialEvaluationsParameter => Parameters[InitialEvaluationsParameterName] as IFixedValueParameter<IntValue>;
+    public IFixedValueParameter<IntValue> MaximumIterationsParameter => Parameters[MaximumIterationsParameterName] as IFixedValueParameter<IntValue>;
+    public IFixedValueParameter<IntValue> MaximumRuntimeParameter => Parameters[MaximumRuntimeParameterName] as IFixedValueParameter<IntValue>;
+    public IValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>> RegressionAlgorithmParameter => Parameters[RegressionAlgorithmParameterName] as IValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>>;
+    public IFixedValueParameter<IntValue> SeedParameter => Parameters[SeedParameterName] as IFixedValueParameter<IntValue>;
+    public FixedValueParameter<BoolValue> SetSeedRandomlyParameter => Parameters[SetSeedRandomlyParameterName] as FixedValueParameter<BoolValue>;
+    #endregion
+
+    #region Properties
+    public int GenerationSize
+    {
+      get { return GenerationSizeParemeter.Value.Value; }
+    }
+    public IInfillCriterion InfillCriterion
+    {
+      get { return InfillCriterionParameter.Value; }
+    }
+    public Algorithm InfillOptimizationAlgorithm
+    {
+      get { return InfillOptimizationAlgorithmParameter.Value; }
+    }
+    public int InfillOptimizationRestarts
+    {
+      get { return InfillOptimizationRestartsParemeter.Value.Value; }
+    }
+    public int InitialEvaluations
+    {
+      get { return InitialEvaluationsParameter.Value.Value; }
+    }
+    public int MaximumIterations
+    {
+      get { return MaximumIterationsParameter.Value.Value; }
+    }
+    public int MaximumRuntime
+    {
+      get { return MaximumRuntimeParameter.Value.Value; }
+    }
+    public IDataAnalysisAlgorithm<IRegressionProblem> RegressionAlgorithm
+    {
+      get { return RegressionAlgorithmParameter.Value; }
+    }
+    public int Seed
+    {
+      get { return SeedParameter.Value.Value; }
+    }
+    public bool SetSeedRandomly
+    {
+      get { return SetSeedRandomlyParameter.Value.Value; }
+    }
+    #endregion
+
+    #region StorableProperties
+    [Storable]
+    private IRandom Random = new MersenneTwister();
+    [Storable]
+    private List<Tuple<RealVector, double>> Samples;
+    #endregion
+
+    #region ResultsProperties
+    private double ResultsBestQuality
+    {
+      get { return ((DoubleValue)Results[BestQualityResultName].Value).Value; }
+      set { ((DoubleValue)Results[BestQualityResultName].Value).Value = value; }
+    }
+    private RealVector ResultsBestSolution
+    {
+      get { return (RealVector)Results[BestSolutionResultName].Value; }
+      set { Results[BestSolutionResultName].Value = value; }
+    }
+    private int ResultsEvaluations
+    {
+      get { return ((IntValue)Results[EvaluatedSoultionsResultName].Value).Value; }
+      set { ((IntValue)Results[EvaluatedSoultionsResultName].Value).Value = value; }
+    }
+    private int ResultsIterations
+    {
+      get { return ((IntValue)Results[IterationsResultName].Value).Value; }
+      set { ((IntValue)Results[IterationsResultName].Value).Value = value; }
+    }
+    private DataTable ResultsQualities
+    {
+      get { return (DataTable)Results[QualitiesChartResultName].Value; }
+    }
+    private DataRow ResultsQualitiesBest
+    {
+      get { return ResultsQualities.Rows[BestQualitiesRowResultName]; }
+    }
+    private DataRow ResultsQualitiesWorst
+    {
+      get { return ResultsQualities.Rows[WorstQualitiesRowResultName]; }
+    }
+    private DataRow ResultsQualitiesIteration
+    {
+      get { return ResultsQualities.Rows[CurrentQualitiesRowResultName]; }
+    }
+    private IRegressionSolution ResultsModel
+    {
+      get { return (IRegressionSolution)Results[RegressionSolutionResultName].Value; }
+      set { Results[RegressionSolutionResultName].Value = value; }
+    }
+    #endregion
+
+    #region HLConstructors
+    [StorableConstructor]
+    protected EfficientGlobalOptimizationAlgorithm(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeseialization() {
+      RegisterEventhandlers();
+    }
+    protected EfficientGlobalOptimizationAlgorithm(EfficientGlobalOptimizationAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+      Random = cloner.Clone(Random);
+      if (original.Samples != null) Samples = original.Samples.Select(x => new Tuple<RealVector, double>(cloner.Clone(x.Item1), x.Item2)).ToList();
+      RegisterEventhandlers();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new EfficientGlobalOptimizationAlgorithm(this, cloner); }
+    public EfficientGlobalOptimizationAlgorithm() {
+      var cmaes = new CMAEvolutionStrategy {
+        MaximumGenerations = 300,
+        PopulationSize = 50
+      };
+      var model = new GaussianProcessRegression {
+        Problem = new RegressionProblem()
+      };
+      model.CovarianceFunctionParameter.Value = new CovarianceRationalQuadraticIso();
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumIterationsParameterName, "", new IntValue(int.MaxValue)));
+      Parameters.Add(new FixedValueParameter<IntValue>(InitialEvaluationsParameterName, "", new IntValue(10)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumRuntimeParameterName, "The maximum runtime in seconds after which the algorithm stops. Use -1 to specify no limit for the runtime", new IntValue(3600)));
+      Parameters.Add(new FixedValueParameter<IntValue>(SeedParameterName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(SetSeedRandomlyParameterName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>>(RegressionAlgorithmParameterName, "The model used to approximate the problem", model));
+      Parameters.Add(new ValueParameter<Algorithm>(InfillOptimizationAlgorithmParameterName, "The algorithm used to solve the expected improvement subproblem", cmaes));
+      Parameters.Add(new FixedValueParameter<IntValue>(InfillOptimizationRestartsParameterName, "Number of restarts of the SubAlgortihm to avoid local optima", new IntValue(1)));
+      Parameters.Add(new FixedValueParameter<IntValue>(GenerationSizeParameterName, "Number points that are sampled every iteration (stadard EGO: 1)", new IntValue(1)));
+      Parameters.Add(new ConstrainedValueParameter<IInfillCriterion>(InfillCriterionParameterName, "Decision what value should decide the next sample"));
+      InfillCriterionParameter.ValidValues.Add(new ExpectedImprovement());
+      InfillCriterionParameter.ValidValues.Add(new ExpectedQuality());
+      InfillCriterionParameter.ValidValues.Add(new ConfidenceBound());
+      SetInfillProblem();
+      RegisterEventhandlers();
+    }
+    #endregion
+
+    protected override void Initialize(CancellationToken cancellationToken) {
+      base.Initialize(cancellationToken);
+      //encoding
+      var enc = Problem.Encoding as RealVectorEncoding;
+      if (enc == null) throw new ArgumentException("The EGO algorithm can only be applied to RealVectorEncodings");
+
+      //random
+      if (SetSeedRandomly) SeedParameter.Value.Value = new System.Random().Next();
+      Random.Reset(Seed);
+      Samples = new List<Tuple<RealVector, double>>();
+
+      //results
+      Results.Add(new Result(IterationsResultName, new IntValue(0)));
+      Results.Add(new Result(EvaluatedSoultionsResultName, new IntValue(0)));
+      Results.Add(new Result(BestSolutionResultName, new RealVector(1)));
+      Results.Add(new Result(BestQualityResultName, new DoubleValue(Problem.Maximization ? double.MinValue : double.MaxValue)));
+      Results.Add(new Result(RegressionSolutionResultName, typeof(IRegressionSolution)));
+      var table = new DataTable(QualitiesChartResultName);
+      table.Rows.Add(new DataRow(BestQualitiesRowResultName));
+      table.Rows.Add(new DataRow(WorstQualitiesRowResultName));
+      table.Rows.Add(new DataRow(CurrentQualitiesRowResultName));
+      Results.Add(new Result(QualitiesChartResultName, table));
+
+      ResultsQualities.Rows.Add(new DataRow("DEBUG:ModelBuildingIterations"));
+
+      //initial samples
+      var points = EgoUtilities.GetUniformRandomDesign(InitialEvaluations, enc.Length, enc.Bounds, Random);
+      foreach (var t in points) {
+        Samples.Add(Evaluate(t));
+        cancellationToken.ThrowIfCancellationRequested();
+      }
+
+      Analyze();
+    }
+
+    protected override void Run(CancellationToken cancellationToken) {
+      for (ResultsIterations = 0; ResultsIterations < MaximumIterations; ResultsIterations++) {
+        try {
+          ResultsModel = BuildModel();
+          cancellationToken.ThrowIfCancellationRequested();
+          for (var i = 0; i < GenerationSize; i++) {
+            var samplepoint = OptimizeInfillProblem();
+            var sample = Evaluate(samplepoint);
+            Samples.Add(sample);
+            cancellationToken.ThrowIfCancellationRequested();
+          }
+
+        }
+        finally {
+          Analyze();
+        }
+      }
+    }
+
+    #region Eventhandling
+    private void RegisterEventhandlers() {
+      DeregisterEventhandlers();
+      RegressionAlgorithmParameter.ValueChanged += OnModelAlgorithmChanged;
+      InfillOptimizationAlgorithmParameter.ValueChanged += OnInfillOptimizationAlgorithmChanged;
+      InfillOptimizationAlgorithm.ProblemChanged += InfillOptimizationProblemChanged;
+      InfillCriterionParameter.ValueChanged += InfillCriterionChanged;
+
+    }
+    private void DeregisterEventhandlers() {
+      RegressionAlgorithmParameter.ValueChanged -= OnModelAlgorithmChanged;
+      InfillOptimizationAlgorithmParameter.ValueChanged -= OnInfillOptimizationAlgorithmChanged;
+      InfillOptimizationAlgorithm.ProblemChanged -= InfillOptimizationProblemChanged;
+      InfillCriterionParameter.ValueChanged -= InfillCriterionChanged;
+    }
+    private void OnInfillOptimizationAlgorithmChanged(object sender, EventArgs args) {
+      SetInfillProblem();
+      InfillOptimizationAlgorithm.ProblemChanged -= InfillOptimizationProblemChanged;
+      InfillOptimizationAlgorithm.ProblemChanged += InfillOptimizationProblemChanged;
+    }
+    private void InfillOptimizationProblemChanged(object sender, EventArgs e) {
+      InfillOptimizationAlgorithm.ProblemChanged -= InfillOptimizationProblemChanged;
+      SetInfillProblem();
+      InfillOptimizationAlgorithm.ProblemChanged += InfillOptimizationProblemChanged;
+    }
+    private void InfillCriterionChanged(object sender, EventArgs e) {
+      var infillProblem = InfillOptimizationAlgorithm.Problem as InfillProblem;
+      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm has no InfillProblem. Troubles with Eventhandling?");
+      infillProblem.InfillCriterion = InfillCriterion;
+    }
+    private void OnModelAlgorithmChanged(object sender, EventArgs args) {
+      RegressionAlgorithm.Problem = new RegressionProblem();
+    }
+    protected override void OnExecutionTimeChanged() {
+      base.OnExecutionTimeChanged();
+      if (CancellationTokenSource == null) return;
+      if (MaximumRuntime == -1) return;
+      if (ExecutionTime.TotalSeconds > MaximumRuntime) CancellationTokenSource.Cancel();
+    }
+    protected override void OnPaused() {
+      base.OnPaused();
+      if (InfillOptimizationAlgorithm.ExecutionState == ExecutionState.Started) InfillOptimizationAlgorithm.Pause();
+      if (RegressionAlgorithm.ExecutionState == ExecutionState.Started) RegressionAlgorithm.Pause();
+
+    }
+    protected override void OnStopped() {
+      base.OnStopped();
+      if (InfillOptimizationAlgorithm.ExecutionState != ExecutionState.Stopped) InfillOptimizationAlgorithm.Stop();
+      if (RegressionAlgorithm.ExecutionState != ExecutionState.Stopped) RegressionAlgorithm.Stop();
+    }
+    protected override void OnProblemChanged() {
+      base.OnProblemChanged();
+      var infillProblem = InfillOptimizationAlgorithm.Problem as InfillProblem;
+      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm has no InfillProblem. Troubles with Eventhandling?");
+      infillProblem.Problem = Problem;
+    }
+    #endregion
+
+    #region helpers
+    private void SetInfillProblem() {
+      var infillProblem = new InfillProblem {
+        InfillCriterion = InfillCriterion,
+        Problem = Problem
+      };
+      InfillOptimizationAlgorithm.Problem = infillProblem;
+    }
+    private IRegressionSolution BuildModel() {
+      var dataset = EgoUtilities.GetDataSet(Samples);
+      var problemdata = new RegressionProblemData(dataset, dataset.VariableNames.Where(x => !x.Equals("output")), "output");
+      problemdata.TrainingPartition.Start = 0;
+      problemdata.TrainingPartition.End = Samples.Count;
+      problemdata.TestPartition.Start = Samples.Count;
+      problemdata.TestPartition.End = Samples.Count;
+
+      //train 
+      var problem = (RegressionProblem)RegressionAlgorithm.Problem;
+      problem.ProblemDataParameter.Value = problemdata;
+      var i = 0;
+      IRegressionSolution solution = null;
+      double r2 = 0;
+      while ((solution == null || RegressionAlgorithm is GaussianProcessRegression && r2 < 0.95) && i++ < 100) {  //TODO: ask why GP degenerates to NaN so often
+        var results = EgoUtilities.SyncRunSubAlgorithm(RegressionAlgorithm, Random.Next(int.MaxValue));
+        solution = results.Select(x => x.Value).OfType<IRegressionSolution>().SingleOrDefault();
+        r2 = solution?.TrainingRSquared ?? 0;
+      }
+      ResultsQualities.Rows["DEBUG:ModelBuildingIterations"].Values.Add(i);
+      if (solution == null) throw new ArgumentException("The Algorithm did not return a Model");
+      return solution;
+    }
+    private RealVector OptimizeInfillProblem() {
+      //parameterize and check InfillProblem
+      var infillProblem = InfillOptimizationAlgorithm.Problem as InfillProblem;
+      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm does not have InfillProblem. Problem with Eventhandling?");
+      if (infillProblem.InfillCriterion != InfillCriterion) throw new ArgumentException("InfillCiriterion for Problem is not correct. Problem with Eventhandling?");
+      if (infillProblem.Problem != Problem) throw new ArgumentException("Expensive real problem is not correctly set in InfillProblem. Problem with Eventhandling?");
+      infillProblem.RegressionSolution = ResultsModel;
+
+      RealVector bestVector = null;
+      var bestValue = infillProblem.Maximization ? double.NegativeInfinity : double.PositiveInfinity;
+
+      for (var i = 0; i < InfillOptimizationRestarts; i++) {
+        //optimize
+        var res = EgoUtilities.SyncRunSubAlgorithm(InfillOptimizationAlgorithm, Random.Next(int.MaxValue));
+
+        //extract results
+        if (!res.ContainsKey(BestInfillSolutionResultName)) throw new ArgumentException("The InfillOptimizationAlgorithm did not return a best solution");
+        var v = res[BestInfillSolutionResultName].Value as RealVector;
+        if (!res.ContainsKey(BestInfillQualityResultName)) throw new ArgumentException("The InfillOptimizationAlgorithm did not return a best quality");
+        var d = res[BestInfillQualityResultName].Value as DoubleValue;
+        if (d == null || v == null) throw new ArgumentException("The InfillOptimizationAlgorithm did not return the expected result types");
+
+        //check for improvement
+        if (infillProblem.Maximization != d.Value > bestValue) continue;
+        bestValue = d.Value;
+        bestVector = v;
+      }
+
+      InfillOptimizationAlgorithm.Runs.Clear();
+      return bestVector;
+    }
+    private Tuple<RealVector, double> Evaluate(RealVector point) {
+      var scope = new Scope();
+      scope.Variables.Add(new Variable(Problem.Encoding.Name, point));
+      var ind = new SingleEncodingIndividual(Problem.Encoding, scope);
+      var q = Problem.Evaluate(ind, Random);
+      return new Tuple<RealVector, double>(point, q);
+    }
+    private void Analyze() {
+      ResultsEvaluations = Samples.Count;
+      var max = Samples.ArgMax(x => x.Item2);
+      var min = Samples.ArgMin(x => x.Item2);
+      var best = Samples[Problem.Maximization ? max : min];
+      ResultsBestQuality = best.Item2;
+      ResultsBestSolution = best.Item1;
+      ResultsQualitiesBest.Values.Add(ResultsBestQuality);
+      ResultsQualitiesIteration.Values.Add(Samples[Samples.Count - 1].Item2);
+      ResultsQualitiesWorst.Values.Add(Samples[Problem.Maximization ? min : max].Item2);
+    }
+    #endregion
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EgoUtilities.cs
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EgoUtilities.cs	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EgoUtilities.cs	(revision 14741)
@@ -0,0 +1,106 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.EGO {
+  internal static class EgoUtilities {
+    public static int ArgMax<T>(this IEnumerable<T> values, Func<T, double> func) {
+      var max = double.MinValue;
+      var maxIdx = 0;
+      var idx = 0;
+      foreach (var v in values) {
+        var d = func.Invoke(v);
+        if (d > max) {
+          max = d;
+          maxIdx = idx;
+        }
+        idx++;
+      }
+      return maxIdx;
+    }
+    public static int ArgMin<T>(this IEnumerable<T> values, Func<T, double> func) {
+      return ArgMax(values, x => -func.Invoke(x));
+    }
+
+    public static ResultCollection SyncRunSubAlgorithm(IAlgorithm alg, int random) {
+      EventWaitHandle trigger = new AutoResetEvent(false);
+      Exception ex = null;
+      EventHandler<EventArgs<Exception>> exhandler = (sender, e) => ex = e.Value;
+      EventHandler stoppedHandler = (sender, e) => trigger.Set();
+      alg.ExceptionOccurred += exhandler;
+      alg.Stopped += stoppedHandler;
+      alg.Prepare();
+      alg.Start();
+      trigger.WaitOne();
+      alg.ExceptionOccurred -= exhandler;
+      alg.Stopped -= stoppedHandler;
+      if (ex != null) throw ex;
+      return alg.Results;
+    }
+    public static RealVector[] GetUniformRandomDesign(int points, int dim, DoubleMatrix bounds, IRandom random) {
+      var res = new RealVector[points];
+      for (var i = 0; i < points; i++) {
+        var r = new RealVector(dim);
+        res[i] = r;
+        for (var j = 0; j < dim; j++) {
+          var b = j % bounds.Rows;
+          r[j] = UniformRandom(bounds[b, 0], bounds[b, 1], random);
+        }
+      }
+      return res;
+    }
+    public static double UniformRandom(double min, double max, IRandom rand) {
+      return rand.NextDouble() * (max - min) + min;
+    }
+
+    public static double GetEstimation(this IRegressionModel model, RealVector r) {
+      var dataset = GetDataSet(new[] { new Tuple<RealVector, double>(r, 0.0) });
+      return model.GetEstimatedValues(dataset, new[] { 0 }).First();
+    }
+    public static double GetVariance(this IConfidenceRegressionModel model, RealVector r) {
+      var dataset = GetDataSet(new[] { new Tuple<RealVector, double>(r, 0.0) });
+      return model.GetEstimatedVariances(dataset, new[] { 0 }).First();
+    }
+
+    public static Dataset GetDataSet(IReadOnlyList<Tuple<RealVector, double>> samples) {
+      var n = samples[0].Item1.Length + 1;
+      var data = new double[samples.Count, n];
+      var names = new string[n - 1];
+      for (var i = 0; i < n; i++)
+        if (i < names.Length) {
+          names[i] = "input" + i;
+          for (var j = 0; j < samples.Count; j++) data[j, i] = samples[j].Item1[i];
+        } else
+          for (var j = 0; j < samples.Count; j++) data[j, n - 1] = samples[j].Item2;
+      return new Dataset(names.Concat(new[] { "output" }).ToArray(), data);
+    }
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/HeuristicLab.Algorithms.EGO-3.4.csproj
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/HeuristicLab.Algorithms.EGO-3.4.csproj	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/HeuristicLab.Algorithms.EGO-3.4.csproj	(revision 14741)
@@ -0,0 +1,141 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{F740AF15-7ADA-40D9-B225-837F4E4F41E0}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.EGO</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.EGO-3.4</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE;DEBUG;CODE_ANALYSIS</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.Algorithms.CMAEvolutionStrategy-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Algorithms.CMAEvolutionStrategy-3.4.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Algorithms.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Algorithms.DataAnalysis-3.4.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Analysis-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis-3.4.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="EgoUtilities.cs" />
+    <Compile Include="EfficientGlobalOptimizationAlgorithm.cs" />
+    <Compile Include="InfillCriteria\RobustImprovement.cs" />
+    <Compile Include="InfillCriteria\ConfidenceBound.cs" />
+    <Compile Include="InfillCriteria\ExpectedQuality.cs" />
+    <Compile Include="InfillCriteria\InfillCriterionBase.cs" />
+    <Compile Include="InfillCriteria\ExpectedImprovement.cs" />
+    <Compile Include="Interfaces\IInfillCriterion.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Problems\InfillProblem.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/ConfidenceBound.cs
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/ConfidenceBound.cs	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/ConfidenceBound.cs	(revision 14741)
@@ -0,0 +1,78 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+// ReSharper disable once CheckNamespace
+namespace HeuristicLab.Algorithms.EGO {
+
+  [StorableClass]
+  [Item("RobustImprovementMeassure", "Adding or Subtracting the variance * factor to the model estimation")]
+  public class RobustImprovement : InfillCriterionBase {
+
+    #region ParameterNames
+    private const string ConfidenceWeightParameterName = "ConfidenceWeight";
+    #endregion
+
+    #region ParameterProperties
+    public IFixedValueParameter<DoubleValue> ConfidenceWeightParameter
+    {
+      get { return Parameters[ConfidenceWeightParameterName] as IFixedValueParameter<DoubleValue>; }
+    }
+    #endregion
+
+    #region Properties
+    private double ConfidenceWeight
+    {
+      get { return ConfidenceWeightParameter.Value.Value; }
+    }
+
+    #endregion
+
+    #region HL-Constructors, Serialization and Cloning 
+    [StorableConstructor]
+    private RobustImprovement(bool deserializing) : base(deserializing) { }
+    private RobustImprovement(RobustImprovement original, Cloner cloner) : base(original, cloner) { }
+    public RobustImprovement() {
+      Parameters.Add(new FixedValueParameter<DoubleValue>(ConfidenceWeightParameterName, "A value between 0 and 1 indicating the focus on exploration (0) or exploitation (1)", new DoubleValue(0.5)));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RobustImprovement(this, cloner);
+    }
+    #endregion
+
+    public override double Evaluate(IRegressionSolution solution, RealVector vector, bool maximization) {
+      var model = solution.Model as IConfidenceRegressionModel;
+      if (model == null) throw new ArgumentException("can not calculate EI without confidence measure");
+      var yhat = model.GetEstimation(vector);
+      var s = Math.Sqrt(model.GetVariance(vector)) * ConfidenceWeight;
+      return maximization ? yhat + s : yhat - s;
+    }
+
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/ExpectedImprovement.cs
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/ExpectedImprovement.cs	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/ExpectedImprovement.cs	(revision 14741)
@@ -0,0 +1,137 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+// ReSharper disable once CheckNamespace
+namespace HeuristicLab.Algorithms.EGO {
+
+  [StorableClass]
+  [Item("ExpectedImprovementMeassure", "Extension of the Expected Improvement to a weighted version by ANDRAS SÓBESTER , STEPHEN J. LEARY and ANDY J. KEANE   in \n On the Design of Optimization Strategies Based on Global Response Surface Approximation Models")]
+  public class ExpectedImprovement : InfillCriterionBase {
+
+    #region ParameterNames
+    private const string ExploitationWeightParameterName = "ExploitationWeight";
+    #endregion
+
+    #region ParameterProperties
+    public IFixedValueParameter<DoubleValue> ExploitationWeightParameter
+    {
+      get { return Parameters[ExploitationWeightParameterName] as IFixedValueParameter<DoubleValue>; }
+    }
+    #endregion
+
+    #region Properties
+    private double ExploitationWeight
+    {
+      get { return ExploitationWeightParameter.Value.Value; }
+    }
+
+    #endregion
+
+    #region HL-Constructors, Serialization and Cloning 
+    [StorableConstructor]
+    private ExpectedImprovement(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventhandlers();
+    }
+    private ExpectedImprovement(ExpectedImprovement original, Cloner cloner) : base(original, cloner) {
+      RegisterEventhandlers();
+    }
+    public ExpectedImprovement() {
+      Parameters.Add(new FixedValueParameter<DoubleValue>(ExploitationWeightParameterName, "A value between 0 and 1 indicating the focus on exploration (0) or exploitation (1)", new DoubleValue(0.5)));
+      RegisterEventhandlers();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExpectedImprovement(this, cloner);
+    }
+    #endregion
+
+    public override double Evaluate(IRegressionSolution solution, RealVector vector, bool maximization) {
+      if (maximization) throw new NotImplementedException("Expected Improvement for maximization not yet implemented");
+      var model = solution.Model as IConfidenceRegressionModel;
+      if (model == null) throw new ArgumentException("can not calculate EI without confidence measure");
+      var yhat = model.GetEstimation(vector);
+      var min = solution.ProblemData.TargetVariableTrainingValues.Min();
+      var s = Math.Sqrt(model.GetVariance(vector));
+      return GetEstimatedImprovement(min, yhat, s, ExploitationWeight);
+    }
+
+    public override bool Maximization(bool expensiveProblemMaximization) {
+      return true;
+    }
+
+    #region Eventhandling
+    private void RegisterEventhandlers() {
+      DeregisterEventhandlers();
+      ExploitationWeightParameter.Value.ValueChanged += OnExploitationWeightChanged;
+    }
+    private void DeregisterEventhandlers() {
+      ExploitationWeightParameter.Value.ValueChanged -= OnExploitationWeightChanged;
+    }
+    private void OnExploitationWeightChanged(object sender, EventArgs e) {
+      ExploitationWeightParameter.Value.ValueChanged -= OnExploitationWeightChanged;
+      ExploitationWeightParameter.Value.Value = Math.Max(0, Math.Min(ExploitationWeight, 1));
+      ExploitationWeightParameter.Value.ValueChanged += OnExploitationWeightChanged;
+    }
+    #endregion
+
+    #region Helpers
+    private static double GetEstimatedImprovement(double ymin, double yhat, double s, double w) {
+      if (Math.Abs(s) < double.Epsilon) return 0;
+      var val = (ymin - yhat) / s;
+      var res = w * (ymin - yhat) * StandardNormalDistribution(val) + (1 - w) * s * StandardNormalDensity(val);
+      return double.IsInfinity(res) || double.IsNaN(res) ? 0 : res;
+    }
+
+    private static double StandardNormalDensity(double x) {
+      if (Math.Abs(x) > 10) return 0;
+      return Math.Exp(-0.5 * x * x) / Math.Sqrt(2 * Math.PI);
+    }
+
+    //taken from https://www.johndcook.com/blog/2009/01/19/stand-alone-error-function-erf/
+    private static double StandardNormalDistribution(double x) {
+      if (x > 10) return 1;
+      if (x < -10) return 0;
+      const double a1 = 0.254829592;
+      const double a2 = -0.284496736;
+      const double a3 = 1.421413741;
+      const double a4 = -1.453152027;
+      const double a5 = 1.061405429;
+      const double p = 0.3275911;
+      var sign = x < 0 ? -1 : 1;
+      x = Math.Abs(x) / Math.Sqrt(2.0);
+      var t = 1.0 / (1.0 + p * x);
+      var y = 1.0 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.Exp(-x * x);
+      return 0.5 * (1.0 + sign * y);
+    }
+    #endregion
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/ExpectedQuality.cs
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/ExpectedQuality.cs	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/ExpectedQuality.cs	(revision 14741)
@@ -0,0 +1,48 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+// ReSharper disable once CheckNamespace
+namespace HeuristicLab.Algorithms.EGO {
+
+  [StorableClass]
+  [Item("ExpectedQualityMeassure", "Use simply the qualitypredicted by the model")]
+  public class ExpectedQuality : InfillCriterionBase {
+    #region HL-Constructors, Serialization and Cloning 
+    [StorableConstructor]
+    private ExpectedQuality(bool deserializing) : base(deserializing) { }
+    private ExpectedQuality(ExpectedQuality original, Cloner cloner) : base(original, cloner) { }
+    public ExpectedQuality() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExpectedQuality(this, cloner);
+    }
+    #endregion
+
+    public override double Evaluate(IRegressionSolution solution, RealVector vector, bool maximization) {
+      return solution.Model.GetEstimation(vector);
+    }
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/InfillCriterionBase.cs
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/InfillCriterionBase.cs	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/InfillCriterionBase.cs	(revision 14741)
@@ -0,0 +1,41 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Problems.DataAnalysis;
+
+// ReSharper disable once CheckNamespace
+namespace HeuristicLab.Algorithms.EGO {
+
+  public abstract class InfillCriterionBase : ParameterizedNamedItem, IInfillCriterion {
+
+    protected InfillCriterionBase(bool deserializing) : base(deserializing) { }
+    protected InfillCriterionBase(InfillCriterionBase original, Cloner cloner) : base(original, cloner) { }
+    protected InfillCriterionBase() { }
+
+    public abstract double Evaluate(IRegressionSolution model, RealVector vector, bool maximization);
+    public virtual bool Maximization(bool expensiveProblemMaximization) {
+      return expensiveProblemMaximization;
+    }
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/RobustImprovement.cs
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/RobustImprovement.cs	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/RobustImprovement.cs	(revision 14741)
@@ -0,0 +1,78 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+// ReSharper disable once CheckNamespace
+namespace HeuristicLab.Algorithms.EGO {
+
+  [StorableClass]
+  [Item("ConfidenceBoundMeassure", "Adding or Subtracting the variance * factor to the model estimation")]
+  public class ConfidenceBound : InfillCriterionBase {
+
+    #region ParameterNames
+    private const string ConfidenceWeightParameterName = "ConfidenceWeight";
+    #endregion
+
+    #region ParameterProperties
+    public IFixedValueParameter<DoubleValue> ConfidenceWeightParameter
+    {
+      get { return Parameters[ConfidenceWeightParameterName] as IFixedValueParameter<DoubleValue>; }
+    }
+    #endregion
+
+    #region Properties
+    private double ConfidenceWeight
+    {
+      get { return ConfidenceWeightParameter.Value.Value; }
+    }
+
+    #endregion
+
+    #region HL-Constructors, Serialization and Cloning 
+    [StorableConstructor]
+    private ConfidenceBound(bool deserializing) : base(deserializing) { }
+    private ConfidenceBound(ConfidenceBound original, Cloner cloner) : base(original, cloner) { }
+    public ConfidenceBound() {
+      Parameters.Add(new FixedValueParameter<DoubleValue>(ConfidenceWeightParameterName, "A value between 0 and 1 indicating the focus on exploration (0) or exploitation (1)", new DoubleValue(0.5)));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConfidenceBound(this, cloner);
+    }
+    #endregion
+
+    public override double Evaluate(IRegressionSolution solution, RealVector vector, bool maximization) {
+      var model = solution.Model as IConfidenceRegressionModel;
+      if (model == null) throw new ArgumentException("can not calculate EI without confidence measure");
+      var yhat = model.GetEstimation(vector);
+      var s = Math.Sqrt(model.GetVariance(vector)) * ConfidenceWeight;
+      return maximization ? yhat + s : yhat - s;
+    }
+
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Interfaces/IInfillCriterion.cs
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Interfaces/IInfillCriterion.cs	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Interfaces/IInfillCriterion.cs	(revision 14741)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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
+
+// ReSharper disable once CheckNamespace
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.EGO {
+  public interface IInfillCriterion : INamedItem {
+    double Evaluate(IRegressionSolution model, RealVector vector, bool maximization);
+    bool Maximization(bool expensiveProblemMaximization);
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Plugin.cs.frame
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Plugin.cs.frame	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Plugin.cs.frame	(revision 14741)
@@ -0,0 +1,48 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Algorithms.EGO {
+  [Plugin("HeuristicLab.Algorithms.EGO", "3.4.5.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.EGO-3.4.dll", PluginFileType.Assembly)]
+  [PluginFile("displayModelFrame.html", PluginFileType.Data)]
+  [PluginDependency("HeuristicLab.Algorithms.CMAEvolutionStrategy", "3.4")]
+  [PluginDependency("HeuristicLab.Algorithms.DataAnalysis", "3.4")]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization","3.3")]
+  [PluginDependency("HeuristicLab.Parameters","3.3")]
+  [PluginDependency("HeuristicLab.Persistence","3.3")]
+  [PluginDependency("HeuristicLab.Problems.DataAnalysis", "3.4")]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  public class HeuristicLabProblemsDataAnalysisSymbolicViewsPlugin : PluginBase {
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Problems/InfillProblem.cs
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Problems/InfillProblem.cs	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Problems/InfillProblem.cs	(revision 14741)
@@ -0,0 +1,108 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Algorithms.EGO;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Problems.SurrogateProblem {
+  [StorableClass]
+  [Item("InfillProblem", "A problem for finding the most interesing potential new sampling Points by optimizing some InfillCriterion")]
+  public sealed class InfillProblem : SingleObjectiveBasicProblem<RealVectorEncoding> {
+
+    [Storable]
+    public override bool Maximization => true;
+
+    #region Properties;
+    [Storable]
+    private IInfillCriterion infillCriterion;
+    [Storable]
+    private SingleObjectiveBasicProblem<IEncoding> problem;
+    [Storable]
+    private IRegressionSolution regressionSolution;
+
+
+    public IInfillCriterion InfillCriterion
+    {
+      get { return infillCriterion; }
+      set { infillCriterion = value; }
+    }
+    public SingleObjectiveBasicProblem<IEncoding> Problem
+    {
+      get { return problem; }
+      set
+      {
+        problem = value;
+        if (problem == null) return;
+        Encoding = problem.Encoding as RealVectorEncoding;
+        if (Encoding == null) throw new ArgumentException("EGO can not be performed on non-RealVectorEncodings");
+      }
+    }
+    public IRegressionSolution RegressionSolution
+    {
+      get { return regressionSolution; }
+      set { regressionSolution = value; }
+    }
+    #endregion
+
+    #region HLConstructors
+    [StorableConstructor]
+    private InfillProblem(bool deserializing) : base(deserializing) { }
+    private InfillProblem(InfillProblem original, Cloner cloner) : base(original, cloner) {
+      infillCriterion = cloner.Clone(original.InfillCriterion);
+      problem = cloner.Clone(original.Problem);
+      regressionSolution = cloner.Clone(original.regressionSolution);
+    }
+    public InfillProblem() { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new InfillProblem(this, cloner); }
+    #endregion
+
+    public override double Evaluate(Individual individual, IRandom r) {
+      var q = InfillCriterion.Evaluate(RegressionSolution, individual.RealVector(), Problem.Maximization);
+      return InfillCriterion.Maximization(Problem.Maximization) ? q : -q; //This is necessary because Maximization is not supposed to change on a normal problem
+    }
+    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      base.Analyze(individuals, qualities, results, random);
+      var best = qualities.ArgMax(x => x);
+      var qnew = InfillCriterion.Maximization(Problem.Maximization) ? qualities[best] : -qualities[best];
+      //var best = Maximization ? qualities.ArgMax(x => x) : qualities.ArgMin(x => x);
+      const string qname = EfficientGlobalOptimizationAlgorithm.BestInfillQualityResultName;
+      const string sname = EfficientGlobalOptimizationAlgorithm.BestInfillSolutionResultName;
+      if (!results.ContainsKey(EfficientGlobalOptimizationAlgorithm.BestInfillQualityResultName)) {
+        results.Add(new Result(sname, (RealVector)individuals[best].RealVector().Clone()));
+        results.Add(new Result(qname, new DoubleValue(qnew)));
+        return;
+      }
+      var qold = results[qname].Value as DoubleValue;
+      if (qold == null) throw new ArgumentException("Old best quality is not a double value. Conflicting Analyzers?");
+      if (qold.Value >= qnew == InfillCriterion.Maximization(Problem.Maximization)) return;
+      results[sname].Value = (RealVector)individuals[best].RealVector().Clone();
+      qold.Value = qnew;
+
+    }
+  }
+}
Index: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Properties/AssemblyInfo.cs.frame
===================================================================
--- branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Properties/AssemblyInfo.cs.frame	(revision 14741)
+++ branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Properties/AssemblyInfo.cs.frame	(revision 14741)
@@ -0,0 +1,55 @@
+﻿#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.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Algorithms.EGO")]
+[assembly: AssemblyDescription("HeuristicLab Efficient Global Optimization")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2017 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("0c41579a-d3c4-49fb-af7a-119eea1155ac")]
+
+// 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("3.4.0.0")]
+[assembly: AssemblyFileVersion("3.4.0.$WCREV$")]
Index: branches/EfficientGlobalOptimization/PreBuildEvent.cmd
===================================================================
--- branches/EfficientGlobalOptimization/PreBuildEvent.cmd	(revision 14741)
+++ branches/EfficientGlobalOptimization/PreBuildEvent.cmd	(revision 14741)
@@ -0,0 +1,2 @@
+IF EXIST "%ProjectDir%\Properties\AssemblyInfo.cs.frame" SubWCRev "%ProjectDir%\" "%ProjectDir%\Properties\AssemblyInfo.cs.frame" "%ProjectDir%\Properties\AssemblyInfo.cs"
+IF EXIST "%ProjectDir%\Plugin.cs.frame" SubWCRev "%ProjectDir%\" "%ProjectDir%\Plugin.cs.frame" "%ProjectDir%\Plugin.cs"
