Changeset 15343 for branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/DiscreteEGO

Timestamp:

08/29/17 11:28:16 (7 years ago)

Author:

bwerth

Message:

#2745 added discretized EGO-version for use with IntegerVectors

Location:

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/DiscreteEGO

Files:

• . (added)
• DiscreteAdaptiveSamplingAlgorithm.cs (copied) (copied from branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/AdaptiveSamplingAlgorithm.cs) (16 diffs)
• DiscreteCorrelationAnalyzer.cs (copied) (copied from branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/CorrelationAnalyzer.cs) (5 diffs)
• DiscreteEfficientGlobalOptimizationAlgorithm.cs (copied) (copied from branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EfficientGlobalOptimizationAlgorithm.cs) (18 diffs)
• DiscreteEvaluatedSolutionsAnalyzer.cs (copied) (copied from branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/EvaluatedSolutionsAnalyzer.cs) (4 diffs)
• DiscreteInfillProblem.cs (copied) (copied from branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Problems/InfillProblem.cs) (8 diffs)
• DiscreteInfillSolver.cs (copied) (copied from branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/InfillSolver.cs) (6 diffs)
• DiscreteSampleCollector.cs (copied) (copied from branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/SampleCollector.cs) (4 diffs)

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/DiscreteEGO/DiscreteAdaptiveSamplingAlgorithm.cs

@@ -8 +8 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -18 +18 @@
 
 namespace HeuristicLab.Algorithms.EGO {
-  [Item("Adaptive Sampling Algorithm (EGO)", "An adaptive sampling algorithm.")]
+  [Item("Discrete Adaptive Sampling Algorithm (D-EGO)", "A discrete adaptive sampling algorithm.")]
   [Creatable(CreatableAttribute.Categories.SingleSolutionAlgorithms, Priority = 150)]
   [StorableClass]
-  public class AdaptiveSamplingAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+  public class DiscreteAdaptiveSamplingAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
     public string Filename { get; set; }
 
@@ -80 +80 @@
     private BestAverageWorstQualityAnalyzer singleObjectiveQualityAnalyzer;
     [Storable]
-    private CorrelationAnalyzer correlationAnalyzer;
-    [Storable]
-    private EvaluatedSolutionsAnalyzer sampleAnalyzer;
+    private DiscreteCorrelationAnalyzer correlationAnalyzer;
+    [Storable]
+    private DiscreteEvaluatedSolutionsAnalyzer sampleAnalyzer;
     [Storable]
     private ModelQualityAnalyzer modelAnalyzer;
@@ -102 +102 @@
     #region Problem-dependent Operators
     [Storable]
-    private SampleCollector sampleCollector;
-    [Storable]
-    private InfillSolver infillSolver;
+    private DiscreteSampleCollector sampleCollector;
+    [Storable]
+    private DiscreteInfillSolver infillSolver;
     [Storable]
     private SolutionsCreator infillSolutionsCreator;
@@ -112 +112 @@
     #region Constructors
     [StorableConstructor]
-    protected AdaptiveSamplingAlgorithm(bool deserializing) : base(deserializing) { }
+    protected DiscreteAdaptiveSamplingAlgorithm(bool deserializing) : base(deserializing) { }
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
       Initialize();
     }
-    protected AdaptiveSamplingAlgorithm(AdaptiveSamplingAlgorithm original, Cloner cloner) : base(original, cloner) {
+    protected DiscreteAdaptiveSamplingAlgorithm(DiscreteAdaptiveSamplingAlgorithm original, Cloner cloner) : base(original, cloner) {
       singleObjectiveQualityAnalyzer = cloner.Clone(original.singleObjectiveQualityAnalyzer);
       evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
@@ -134 +134 @@
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new AdaptiveSamplingAlgorithm(this, cloner);
-    }
-    public AdaptiveSamplingAlgorithm() {
+      return new DiscreteAdaptiveSamplingAlgorithm(this, cloner);
+    }
+    public DiscreteAdaptiveSamplingAlgorithm() {
 
       #region Add parameters
@@ -148 +148 @@
         new PluginExpectedImprovement()
       };
-      var cmaes = new CMAEvolutionStrategy.CMAEvolutionStrategy {
-        MaximumGenerations = 300,
-        PopulationSize = 50,
-        Problem = new InfillProblem()
+      var cmaes = new OffspringSelectionGeneticAlgorithm.OffspringSelectionGeneticAlgorithm {
+        MaximumGenerations = new IntValue(300),
+        PopulationSize = new IntValue(50),
+        Problem = new DiscreteInfillProblem()
       };
       var model = new GaussianProcessRegression {
@@ -194 +194 @@
       Operators.Add(modelbuilder);
 
-      sampleCollector = new SampleCollector { Name = "Collect Sample" };
+      sampleCollector = new DiscreteSampleCollector { Name = "Collect Sample" };
       Operators.Add(sampleCollector);
       infillSolutionsCreator = new SolutionsCreator { Name = "Create Adaptive Solutions" };
       Operators.Add(infillSolutionsCreator);
-      infillSolver = new InfillSolver();
+      infillSolver = new DiscreteInfillSolver();
       Operators.Add(infillSolver);
 
@@ -230 +230 @@
       variableCreator.CollectedValues.Add(new ValueParameter<IRegressionSolution>(modelVariableName, "The regression solution representing the model for EGO", null));
       variableCreator.CollectedValues.Add(new FixedValueParameter<BoolValue>(initialPhaseVariableName, new BoolValue(false)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleMatrix>(infillBoundsVariableName));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntMatrix>(infillBoundsVariableName));
       variableCreator.Successor = resultsCollector;
 
@@ -301 +301 @@
       Operators.Add(singleObjectiveQualityAnalyzer);
 
-      correlationAnalyzer = new CorrelationAnalyzer();
+      correlationAnalyzer = new DiscreteCorrelationAnalyzer();
       correlationAnalyzer.ModelParameter.ActualName = modelVariableName;
       Operators.Add(correlationAnalyzer);
 
-      sampleAnalyzer = new EvaluatedSolutionsAnalyzer();
+      sampleAnalyzer = new DiscreteEvaluatedSolutionsAnalyzer();
       sampleAnalyzer.PhaseParameter.ActualName = initialPhaseVariableName;
       Operators.Add(sampleAnalyzer);
@@ -354 +354 @@
     public override void Start(CancellationToken cancellationToken) {
       ParameterizeProblemSpecificOperators();
-      ((InfillProblem)InfillOptimizationAlgorithm.Problem).InfillCriterion = InfillCriterion;
+      ((DiscreteInfillProblem)InfillOptimizationAlgorithm.Problem).InfillCriterion = InfillCriterion;
       ParameterizeCancellableOperators(cancellationToken);
       base.Start(cancellationToken);
@@ -387 +387 @@
       singleObjectiveQualityAnalyzer.QualityParameter.Depth = 1;
       correlationAnalyzer.QualityParameter.Depth = 1;
-      correlationAnalyzer.RealVectorParameter.Depth = 1;
+      correlationAnalyzer.IntegerVectorParameter.Depth = 1;
       sampleAnalyzer.QualityParameter.Depth = 1;
-      sampleAnalyzer.RealVectorParameter.Depth = 1;
+      sampleAnalyzer.IntegerVectorParameter.Depth = 1;
 
       if (SingleObjectiveProblem == null) return;
@@ -418 +418 @@
       if (SingleObjectiveProblem == null) throw new ArgumentException("Adaptive sampling requires a single objective problem");
       infillSolver.MaximizationParameter.ActualName = SingleObjectiveProblem.MaximizationParameter.Name;
-      var rcreator = Problem.SolutionCreator as IRealVectorCreator;
-      if (rcreator == null) throw new ArgumentException("Adaptive sampling requires real vectors as solution candidates");
+      var rcreator = Problem.SolutionCreator as IIntegerVectorCreator;
+      if (rcreator == null) throw new ArgumentException("Discrete Adaptive sampling requires integer vectors as solution candidates");
 
       infillSolver.LengthParameter.ActualName = rcreator.LengthParameter.ActualName;
@@ -425 +425 @@
       infillSolver.LengthParameter.Value = rcreator.LengthParameter.Value;
       infillSolver.BoundsParameter.Value = rcreator.BoundsParameter.Value;
-      infillSolver.RealVectorParameter.ActualName = rcreator.RealVectorParameter.ActualName;
-
-      sampleCollector.RealVectorParameter.ActualName = rcreator.RealVectorParameter.ActualName;
+      infillSolver.IntegerVectorParameter.ActualName = rcreator.IntegerVectorParameter.ActualName;
+
+      sampleCollector.IntegerVectorParameter.ActualName = rcreator.IntegerVectorParameter.ActualName;
       sampleCollector.QualityParameter.ActualName = SingleObjectiveProblem.Evaluator.QualityParameter.ActualName;
 
-      correlationAnalyzer.RealVectorParameter.ActualName = rcreator.RealVectorParameter.ActualName;
-      sampleAnalyzer.RealVectorParameter.ActualName = rcreator.RealVectorParameter.ActualName;
+      correlationAnalyzer.IntegerVectorParameter.ActualName = rcreator.IntegerVectorParameter.ActualName;
+      sampleAnalyzer.IntegerVectorParameter.ActualName = rcreator.IntegerVectorParameter.ActualName;
     }
     private void ParameterizeCancellableOperators(CancellationToken cancellation) {
@@ -451 +451 @@
     }
     private void OnInfillCriterionChanged(object sender, EventArgs e) {
-      ((InfillProblem)InfillOptimizationAlgorithm.Problem).InfillCriterion = InfillCriterion;
+      ((DiscreteInfillProblem)InfillOptimizationAlgorithm.Problem).InfillCriterion = InfillCriterion;
     }
     private void OnInfillAlgorithmChanged(object sender, EventArgs e) {
-      InfillOptimizationAlgorithm.Problem = new InfillProblem { InfillCriterion = InfillCriterion };
+      InfillOptimizationAlgorithm.Problem = new DiscreteInfillProblem { InfillCriterion = InfillCriterion };
       InfillOptimizationAlgorithm.ProblemChanged -= OnInfillProblemChanged; //avoid double attaching
       InfillOptimizationAlgorithm.ProblemChanged += OnInfillProblemChanged;
@@ -461 +461 @@
       //enforce an infill problem for the infill optimization algorithm
       InfillOptimizationAlgorithm.ProblemChanged -= OnInfillProblemChanged;
-      InfillOptimizationAlgorithm.Problem = new InfillProblem { InfillCriterion = InfillCriterion };
+      InfillOptimizationAlgorithm.Problem = new DiscreteInfillProblem { InfillCriterion = InfillCriterion };
       InfillOptimizationAlgorithm.ProblemChanged += OnInfillProblemChanged;
     }

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/DiscreteEGO/DiscreteCorrelationAnalyzer.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -34 +34 @@
 
 namespace HeuristicLab.Algorithms.EGO {
-  [Item("CorrelationAnalyzer", "Analyzes the correlation between perdictions and actual fitness values")]
+  [Item("DiscreteCorrelationAnalyzer", "Analyzes the correlation between perdictions and actual fitness values")]
   [StorableClass]
-  public class CorrelationAnalyzer : SingleSuccessorOperator, IAnalyzer, IResultsOperator {
+  public class DiscreteCorrelationAnalyzer : SingleSuccessorOperator, IAnalyzer, IResultsOperator {
     public override bool CanChangeName => true;
     public bool EnabledByDefault => false;
 
-    public IScopeTreeLookupParameter<RealVector> RealVectorParameter => (IScopeTreeLookupParameter<RealVector>)Parameters["RealVector"];
+    public IScopeTreeLookupParameter<IntegerVector> IntegerVectorParameter => (IScopeTreeLookupParameter<IntegerVector>)Parameters["IntegerVector"];
     public IScopeTreeLookupParameter<DoubleValue> QualityParameter => (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"];
     public ILookupParameter<IRegressionSolution> ModelParameter => (ILookupParameter<IRegressionSolution>)Parameters["Model"];
@@ -49 +49 @@
 
     [StorableConstructor]
-    protected CorrelationAnalyzer(bool deserializing) : base(deserializing) { }
-    protected CorrelationAnalyzer(CorrelationAnalyzer original, Cloner cloner) : base(original, cloner) { }
-    public CorrelationAnalyzer() {
-      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "The vector which should be collected."));
+    protected DiscreteCorrelationAnalyzer(bool deserializing) : base(deserializing) { }
+    protected DiscreteCorrelationAnalyzer(DiscreteCorrelationAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public DiscreteCorrelationAnalyzer() {
+      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("IntegerVector", "The vector which should be collected."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality associated which this vector"));
       Parameters.Add(new LookupParameter<IRegressionSolution>("Model", "The model of this iteration"));
@@ -59 +59 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new CorrelationAnalyzer(this, cloner);
+      return new DiscreteCorrelationAnalyzer(this, cloner);
     }
 
@@ -66 +66 @@
       var results = ResultsParameter.ActualValue;
       var q = QualityParameter.ActualValue.Select(x => x.Value).ToArray();
-      var p = RealVectorParameter.ActualValue.ToArray();
+      var p = IntegerVectorParameter.ActualValue.ToArray();
       if (model == null) return base.Apply();
       var plot = CreateScatterPlotResult(results);

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/DiscreteEGO/DiscreteEfficientGlobalOptimizationAlgorithm.cs

@@ -25 +25 @@
 using System.Threading;
 using HeuristicLab.Algorithms.DataAnalysis;
+using HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm;
 using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -40 +41 @@
   [StorableClass]
   [Creatable(CreatableAttribute.Categories.Algorithms, Priority = 95)]
-  [Item("EfficientGlobalOptimizationAlgorithm", "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, ISurrogateAlgorithm<RealVector> {
+  [Item("DiscreteEfficientGlobalOptimizationAlgorithm", "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 DiscreteEfficientGlobalOptimizationAlgorithm : BasicAlgorithm, ISurrogateAlgorithm<IntegerVector> {
     #region Basic-Alg-Essentials
     public override bool SupportsPause => true;
@@ -95 +96 @@
     public IFixedValueParameter<BoolValue> RemoveDuplicatesParameter => Parameters[RemoveDuplicatesParamterName] as IFixedValueParameter<BoolValue>;
     public IFixedValueParameter<FileValue> InitialSamplesParameter => Parameters[InitialSamplesParameterName] as IFixedValueParameter<FileValue>;
-    public IValueParameter<RealVector> BaselineVectorParameter => Parameters[BaselineVectorParameterName] as IValueParameter<RealVector>;
-    public IConstrainedValueParameter<IInitialSampling> InitialSamplingPlanParameter => Parameters[InitialSamplingPlanParamterName] as IConstrainedValueParameter<IInitialSampling>;
+    public IValueParameter<IntegerVector> BaselineVectorParameter => Parameters[BaselineVectorParameterName] as IValueParameter<IntegerVector>;
+    public IConstrainedValueParameter<IInitialSampling<IntegerVector>> InitialSamplingPlanParameter => Parameters[InitialSamplingPlanParamterName] as IConstrainedValueParameter<IInitialSampling<IntegerVector>>;
     #endregion
 
@@ -111 +112 @@
     public bool SetSeedRandomly => SetSeedRandomlyParameter.Value.Value;
     public int MaximalDatasetSize => MaximalDataSetSizeParameter.Value.Value;
-    private IEnumerable<Tuple<RealVector, double>> DataSamples => Samples.Count > MaximalDatasetSize && MaximalDatasetSize > 0
+    private IEnumerable<Tuple<IntegerVector, double>> DataSamples => Samples.Count > MaximalDatasetSize && MaximalDatasetSize > 0
       ? Samples.Skip(Samples.Count - MaximalDatasetSize)
       : Samples;
     private bool RemoveDuplicates => RemoveDuplicatesParameter.Value.Value;
-    private RealVector BaselineVector => BaselineVectorParameter.Value;
-    private IInitialSampling InitialSamplingPlan => InitialSamplingPlanParameter.Value;
+    private IntegerVector BaselineVector => BaselineVectorParameter.Value;
+    private IInitialSampling<IntegerVector> InitialSamplingPlan => InitialSamplingPlanParameter.Value;
     #endregion
 
@@ -123 +124 @@
     private IRandom Random = new MersenneTwister();
     [Storable]
-    private List<Tuple<RealVector, double>> Samples;
+    private List<Tuple<IntegerVector, double>> Samples;
     [Storable]
-    private List<Tuple<RealVector, double>> InitialSamples;
+    private List<Tuple<IntegerVector, double>> InitialSamples;
     #endregion
 
@@ -133 +134 @@
       set { ((DoubleValue)Results[BestQualityResultName].Value).Value = value; }
     }
-    private RealVector ResultsBestSolution {
-      get { return (RealVector)Results[BestSolutionResultName].Value; }
+    private IntegerVector ResultsBestSolution {
+      get { return (IntegerVector)Results[BestSolutionResultName].Value; }
       set { Results[BestSolutionResultName].Value = value; }
     }
@@ -157 +158 @@
     #region HLConstructors
     [StorableConstructor]
-    protected EfficientGlobalOptimizationAlgorithm(bool deserializing) : base(deserializing) { }
+    protected DiscreteEfficientGlobalOptimizationAlgorithm(bool deserializing) : base(deserializing) { }
     [StorableHook(HookType.AfterDeserialization)]
     protected void AfterDeseialization() {
       RegisterEventhandlers();
     }
-    protected EfficientGlobalOptimizationAlgorithm(EfficientGlobalOptimizationAlgorithm original, Cloner cloner) : base(original, cloner) {
+    protected DiscreteEfficientGlobalOptimizationAlgorithm(DiscreteEfficientGlobalOptimizationAlgorithm 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();
-      if (original.InitialSamples != null) InitialSamples = original.InitialSamples.Select(x => new Tuple<RealVector, double>(cloner.Clone(x.Item1), x.Item2)).ToList();
+      if (original.Samples != null) Samples = original.Samples.Select(x => new Tuple<IntegerVector, double>(cloner.Clone(x.Item1), x.Item2)).ToList();
+      if (original.InitialSamples != null) InitialSamples = original.InitialSamples.Select(x => new Tuple<IntegerVector, double>(cloner.Clone(x.Item1), x.Item2)).ToList();
       RegisterEventhandlers();
     }
-    public override IDeepCloneable Clone(Cloner cloner) { return new EfficientGlobalOptimizationAlgorithm(this, cloner); }
-    public EfficientGlobalOptimizationAlgorithm() {
+    public override IDeepCloneable Clone(Cloner cloner) { return new DiscreteEfficientGlobalOptimizationAlgorithm(this, cloner); }
+    public DiscreteEfficientGlobalOptimizationAlgorithm() {
       IProblemInstanceExporter dummy = new RegressionProblem(); //this variable is irrelevant
       //the dummy variable enforces a using-Statement for HeuristicLab.Problems.Instances
-      //"new ValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>>" requires no using using-Statement, but nontheless it requires HeuristicLab.Problems.Instances to be referenced  
+      //"new ValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>>" requires no using-Statement, but nontheless it requires HeuristicLab.Problems.Instances to be referenced  
       //Having HeuristicLab.Problems.Instances referenced but not used, causes the Essential-Unit-tests to fail. 
 
-      var cmaes = new CMAEvolutionStrategy.CMAEvolutionStrategy {
-        MaximumGenerations = 300,
-        PopulationSize = 50
+      var cmaes = new OffspringSelectionGeneticAlgorithm.OffspringSelectionGeneticAlgorithm() {
+        MaximumGenerations = new IntValue(300),
+        PopulationSize = new IntValue(50)
       };
       var model = new GaussianProcessRegression {
@@ -195 +196 @@
       Parameters.Add(new FixedValueParameter<BoolValue>(RemoveDuplicatesParamterName, "Wether duplicate samples should be replaced by a single sample with an averaged quality. This GREATLY decreases the chance of ill conditioned models (unbuildable models) but is not theoretically sound as the model ignores the increasing certainty in this region"));
       Parameters.Add(new FixedValueParameter<FileValue>(InitialSamplesParameterName, "The file specifying some initial samples used to jump start the algorithm. These samples are not counted as evaluations. If InitialEvaluations is more than the samples specified in the file, the rest is uniformly random generated and evaluated.", new FileValue()));
-      Parameters.Add(new ValueParameter<RealVector>(BaselineVectorParameterName, "A vector used to create a baseline, this vector is evaluated once and is not part of the modeling process (has no influence on algorithm performance)"));
+      Parameters.Add(new ValueParameter<IntegerVector>(BaselineVectorParameterName, "A vector used to create a baseline, this vector is evaluated once and is not part of the modeling process (has no influence on algorithm performance)"));
       var eqi = new ExpectedQuantileImprovement();
       eqi.MaxEvaluationsParameter.Value = MaximumEvaluationsParameter.Value;
       var criteria = new ItemSet<IInfillCriterion> { new ExpectedImprovement(), new AugmentedExpectedImprovement(), new ExpectedQuality(), eqi, new MinimalQuantileCriterium(), new PluginExpectedImprovement() };
       Parameters.Add(new ConstrainedValueParameter<IInfillCriterion>(InfillCriterionParameterName, "Decision what value should decide the next sample", criteria, criteria.First()));
-      var intialSamplingPlans = new ItemSet<IInitialSampling> { new UniformRandomSampling(), new LatinHyperCubeDesignCreator() };
-      Parameters.Add(new ConstrainedValueParameter<IInitialSampling>(InitialSamplingPlanParamterName, "Determies the initial samples from which the first model can be built.", intialSamplingPlans, intialSamplingPlans.First()));
+      var intialSamplingPlans = new ItemSet<IInitialSampling<IntegerVector>> { new UniformRandomDiscreteSampling() };
+      Parameters.Add(new ConstrainedValueParameter<IInitialSampling<IntegerVector>>(InitialSamplingPlanParamterName, "Determies the initial samples from which the first model can be built.", intialSamplingPlans, intialSamplingPlans.First()));
       SetInfillProblem();
       RegisterEventhandlers();
     }
     #endregion
-    public void SetInitialSamples(RealVector[] individuals, double[] qualities) {
-      InitialSamples = individuals.Zip(qualities, (individual, d) => new Tuple<RealVector, double>(individual, d)).ToList();
+    public void SetInitialSamples(IntegerVector[] individuals, double[] qualities) {
+      InitialSamples = individuals.Zip(qualities, (individual, d) => new Tuple<IntegerVector, double>(individual, d)).ToList();
     }
     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");
-      var infillProblem = InfillOptimizationAlgorithm.Problem as InfillProblem;
-      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm has no InfillProblem. Troubles with Eventhandling?");
+      var enc = Problem.Encoding as IntegerVectorEncoding;
+      if (enc == null) throw new ArgumentException("The EGO algorithm can only be applied to IntegerVectorEncodings");
+      var infillProblem = InfillOptimizationAlgorithm.Problem as DiscreteInfillProblem;
+      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm has no DiscreteInfillProblem. Troubles with Eventhandling?");
 
       //random
       if (SetSeedRandomly) SeedParameter.Value.Value = new System.Random().Next();
       Random.Reset(Seed);
-      Samples = InitialSamples?.ToList() ?? new List<Tuple<RealVector, double>>();
+      Samples = InitialSamples?.ToList() ?? new List<Tuple<IntegerVector, double>>();
 
       //results
       Results.Add(new Result(IterationsResultName, new IntValue(0)));
       Results.Add(new Result(EvaluatedSoultionsResultName, new IntValue(Samples.Count)));
-      Results.Add(new Result(BestSolutionResultName, new RealVector(1)));
+      Results.Add(new Result(BestSolutionResultName, new IntegerVector(1)));
       Results.Add(new Result(BestQualityResultName, new DoubleValue(Problem.Maximization ? double.MinValue : double.MaxValue)));
       Results.Add(new Result(RegressionSolutionResultName, typeof(IRegressionSolution)));
@@ -241 +242 @@
       //initial samples
       if (Samples.Count < InitialEvaluations) {
-        var points = InitialSamplingPlan.GetSamples(InitialEvaluations - Samples.Count, Samples.Select(x => x.Item1).ToArray(), (RealVectorEncoding)Problem.Encoding, Random);
+        var points = InitialSamplingPlan.GetSamples(InitialEvaluations - Samples.Count, Samples.Select(x => x.Item1).ToArray(), (IntegerVectorEncoding)Problem.Encoding, Random);
         foreach (var t in points) {
           try {
             Samples.Add(Evaluate(t));
             cancellationToken.ThrowIfCancellationRequested();
-          } finally {
+          }
+          finally {
             Analyze();
           }
@@ -259 +261 @@
           for (var i = 0; i < GenerationSize; i++) {
             var samplepoint = OptimizeInfillProblem(cancellationToken);
+            if (RemoveDuplicates) {
+
+            }
             var sample = Evaluate(samplepoint);
             Samples.Add(sample);
@@ -264 +269 @@
           }
 
-        } finally {
+        }
+        finally {
           Analyze();
         }
@@ -298 +304 @@
     }
     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?");
+      var infillProblem = InfillOptimizationAlgorithm.Problem as DiscreteInfillProblem;
+      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm has no DiscreteInfillProblem. Troubles with Eventhandling?");
       infillProblem.InfillCriterion = InfillCriterion;
     }
@@ -326 +332 @@
     #region helpers
     private IRegressionSolution BuildModel(CancellationToken cancellationToken) {
-      var dataset = EgoUtilities.GetDataSet(DataSamples.ToList(), RemoveDuplicates);
+      var dataset = EgoUtilities.GetDataSet(DataSamples.ToList());
       var problemdata = new RegressionProblemData(dataset, dataset.VariableNames.Where(x => !x.Equals("output")), "output");
       problemdata.TrainingPartition.Start = 0;
@@ -363 +369 @@
             solution = sol;
           }
-        } catch (ArgumentException) { }
+        }
+        catch (ArgumentException) { }
       }
 
@@ -380 +387 @@
       return solution;
     }
-    private RealVector OptimizeInfillProblem(CancellationToken cancellationToken) {
+    private IntegerVector OptimizeInfillProblem(CancellationToken cancellationToken) {
       //parameterize and check InfillProblem
-      var infillProblem = InfillOptimizationAlgorithm.Problem as InfillProblem;
+      var infillProblem = InfillOptimizationAlgorithm.Problem as DiscreteInfillProblem;
       if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm does not have an InfillProblem.");
       if (infillProblem.InfillCriterion != InfillCriterion) throw new ArgumentException("InfillCiriterion for Problem is not correctly set.");
-      var enc = Problem.Encoding as RealVectorEncoding;
+      var enc = Problem.Encoding as IntegerVectorEncoding;
       infillProblem.Encoding.Bounds = enc.Bounds;
       infillProblem.Encoding.Length = enc.Length;
@@ -392 +399 @@
 
 
-      RealVector bestVector = null;
+      IntegerVector bestVector = null;
       var bestValue = infillProblem.Maximization ? double.NegativeInfinity : double.PositiveInfinity;
       for (var i = 0; i < InfillOptimizationRestarts; i++) {
@@ -399 +406 @@
         cancellationToken.ThrowIfCancellationRequested();
         //extract results
-        if (!res.ContainsKey(InfillProblem.BestInfillSolutionResultName)) throw new ArgumentException("The InfillOptimizationAlgorithm did not return a best solution");
-        var v = res[InfillProblem.BestInfillSolutionResultName].Value as RealVector;
-        if (!res.ContainsKey(InfillProblem.BestInfillQualityResultName)) throw new ArgumentException("The InfillOptimizationAlgorithm did not return a best quality");
-        var d = res[InfillProblem.BestInfillQualityResultName].Value as DoubleValue;
+        if (!res.ContainsKey(DiscreteInfillProblem.BestInfillSolutionResultName)) throw new ArgumentException("The InfillOptimizationAlgorithm did not return a best solution");
+        var v = res[DiscreteInfillProblem.BestInfillSolutionResultName].Value as IntegerVector;
+        if (!res.ContainsKey(DiscreteInfillProblem.BestInfillQualityResultName)) throw new ArgumentException("The InfillOptimizationAlgorithm did not return a best quality");
+        var d = res[DiscreteInfillProblem.BestInfillQualityResultName].Value as DoubleValue;
         if (d == null || v == null) throw new ArgumentException("The InfillOptimizationAlgorithm did not return the expected result types");
         //check for improvement
@@ -456 +463 @@
     }
 
-    private Individual GetIndividual(RealVector r) {
+
+
+    private Individual GetIndividual(IntegerVector r) {
       var scope = new Scope();
       scope.Variables.Add(new Variable(Problem.Encoding.Name, r));
       return new SingleEncodingIndividual(Problem.Encoding, scope);
     }
-    private Tuple<RealVector, double> Evaluate(RealVector point) {
-      return new Tuple<RealVector, double>(point, Problem.Evaluate(GetIndividual(point), Random));
+    private Tuple<IntegerVector, double> Evaluate(IntegerVector point) {
+      return new Tuple<IntegerVector, double>(point, Problem.Evaluate(GetIndividual(point), Random));
     }
 
     private void SetInfillProblem() {
-      InfillOptimizationAlgorithm.Problem = new InfillProblem { InfillCriterion = InfillCriterion };
+      InfillOptimizationAlgorithm.Problem = new DiscreteInfillProblem { InfillCriterion = InfillCriterion };
     }
     #endregion

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/DiscreteEGO/DiscreteEvaluatedSolutionsAnalyzer.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -33 +33 @@
 
 namespace HeuristicLab.Algorithms.EGO {
-  /// <summary>
-  /// A base class for operators that manipulate real-valued vectors.
-  /// </summary>
-  [Item("EvaluatedSolutionsAnalyzer", "Displays the evaluated Solutions for one or two dimensional problems")]
+  [Item("DiscreteEvaluatedSolutionsAnalyzer", "Displays the evaluated Solutions for one or two dimensional problems")]
   [StorableClass]
-  public class EvaluatedSolutionsAnalyzer : SingleSuccessorOperator, IAnalyzer, IResultsOperator {
+  public class DiscreteEvaluatedSolutionsAnalyzer : SingleSuccessorOperator, IAnalyzer, IResultsOperator {
     public override bool CanChangeName => true;
     public bool EnabledByDefault => false;
 
-    public IScopeTreeLookupParameter<RealVector> RealVectorParameter => (IScopeTreeLookupParameter<RealVector>)Parameters["RealVector"];
+    public IScopeTreeLookupParameter<IntegerVector> IntegerVectorParameter => (IScopeTreeLookupParameter<IntegerVector>)Parameters["IntegerVector"];
     public IScopeTreeLookupParameter<DoubleValue> QualityParameter => (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"];
     public ILookupParameter<ResultCollection> ResultsParameter => (ILookupParameter<ResultCollection>)Parameters["Results"];
@@ -53 +50 @@
 
     [StorableConstructor]
-    protected EvaluatedSolutionsAnalyzer(bool deserializing) : base(deserializing) { }
-    protected EvaluatedSolutionsAnalyzer(EvaluatedSolutionsAnalyzer original, Cloner cloner) : base(original, cloner) { }
-    public EvaluatedSolutionsAnalyzer() {
-      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "The vector which should be collected."));
+    protected DiscreteEvaluatedSolutionsAnalyzer(bool deserializing) : base(deserializing) { }
+    protected DiscreteEvaluatedSolutionsAnalyzer(DiscreteEvaluatedSolutionsAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public DiscreteEvaluatedSolutionsAnalyzer() {
+      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("IntegerVector", "The vector which should be collected."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality associated which this vector"));
       Parameters.Add(new LookupParameter<BoolValue>("InitialPhase", "Whether the initial phase has finished"));
@@ -63 +60 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new EvaluatedSolutionsAnalyzer(this, cloner);
+      return new DiscreteEvaluatedSolutionsAnalyzer(this, cloner);
     }
 
     public sealed override IOperation Apply() {
-      var p = RealVectorParameter.ActualValue.ToArray();
+      var p = IntegerVectorParameter.ActualValue.ToArray();
       if (p.Length == 0 || p[0].Length > 2 || p[0].Length == 0) return base.Apply();
       var results = ResultsParameter.ActualValue;

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/DiscreteEGO/DiscreteInfillProblem.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Optimization;
@@ -33 +34 @@
 namespace HeuristicLab.Algorithms.EGO {
   [StorableClass]
-  [Item("InfillProblem", "A problem for finding the most interesing potential new sampling Points by optimizing some InfillCriterion")]
-  public sealed class InfillProblem : SingleObjectiveBasicProblem<RealVectorEncoding> {
+  [Item("DiscreteInfillProblem", "A problem for finding the most interesing potential new sampling Points by optimizing some InfillCriterion")]
+  public sealed class DiscreteInfillProblem : SingleObjectiveBasicProblem<IntegerVectorEncoding> {
 
     public override bool Maximization => true;
@@ -47 +48 @@
     private IInfillCriterion infillCriterion;
 
-    public IInfillCriterion InfillCriterion
-    {
+    public IInfillCriterion InfillCriterion {
       get { return infillCriterion; }
-      set
-      {
+      set {
         infillCriterion = value;
-        infillCriterion.Encoding = Encoding;
+        infillCriterion.Encoding = GetRealVectorEncoding(Encoding);
       }
     }
@@ -60 +59 @@
     #region Constructors
     [StorableConstructor]
-    private InfillProblem(bool deserializing) : base(deserializing) { }
-    private InfillProblem(InfillProblem original, Cloner cloner) : base(original, cloner) {
+    private DiscreteInfillProblem(bool deserializing) : base(deserializing) { }
+    private DiscreteInfillProblem(DiscreteInfillProblem original, Cloner cloner) : base(original, cloner) {
       infillCriterion = cloner.Clone(original.infillCriterion);
     }
-    public InfillProblem() { }
-    public override IDeepCloneable Clone(Cloner cloner) { return new InfillProblem(this, cloner); }
+    public DiscreteInfillProblem() { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new DiscreteInfillProblem(this, cloner); }
     #endregion
 
     public override double Evaluate(Individual individual, IRandom r) {
-      return !InBounds(individual.RealVector(), Encoding.Bounds) ? double.MinValue : InfillCriterion.Evaluate(individual.RealVector());
+      return !InBounds(individual.IntegerVector(), Encoding.Bounds) ? double.MinValue : InfillCriterion.Evaluate(individual.IntegerVector().ToRealVector());
     }
     public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
@@ -76 +75 @@
       var newQuality = qualities[best];
       if (!results.ContainsKey(BestInfillQualityResultName)) {
-        results.Add(new Result(BestInfillSolutionResultName, (RealVector)individuals[best].RealVector().Clone()));
+        results.Add(new Result(BestInfillSolutionResultName, (IntegerVector)individuals[best].IntegerVector().Clone()));
         results.Add(new Result(BestInfillQualityResultName, new DoubleValue(newQuality)));
         return;
@@ -83 +82 @@
       if (qold == null) throw new ArgumentException("Old best quality is not a double value. Conflicting Analyzers?");
       if (qold.Value >= newQuality) return;
-      results[BestInfillSolutionResultName].Value = (RealVector)individuals[best].RealVector().Clone();
+      results[BestInfillSolutionResultName].Value = (IntegerVector)individuals[best].IntegerVector().Clone();
       qold.Value = newQuality;
     }
@@ -89 +88 @@
       var bounds = Encoding.Bounds;
       var michalewiczIteration = 0;
+      var sigma = new DoubleArray(new double[] { 1.0 });
+
       while (true) {
         var neighbour = individual.Copy();
-        var r = neighbour.RealVector();
-        switch (random.Next(5)) {
-          case 0: UniformOnePositionManipulator.Apply(random, r, bounds); break;
-          case 1: UniformOnePositionManipulator.Apply(random, r, bounds); break;//FixedNormalAllPositionsManipulator.Apply(random, r, new RealVector(new[] { 0.1 })); break;
-          case 2: MichalewiczNonUniformAllPositionsManipulator.Apply(random, r, bounds, new IntValue(michalewiczIteration++), new IntValue(10000), new DoubleValue(5.0)); break;
-          case 3: MichalewiczNonUniformOnePositionManipulator.Apply(random, r, bounds, new IntValue(michalewiczIteration++), new IntValue(10000), new DoubleValue(5.0)); break;
-          case 4: BreederGeneticAlgorithmManipulator.Apply(random, r, bounds, new DoubleValue(0.1)); break;
+        var r = neighbour.IntegerVector();
+        switch (random.Next(3) % 3) {
+          case 0: HeuristicLab.Encodings.IntegerVectorEncoding.UniformOnePositionManipulator.Apply(random, r, bounds); break;
+          case 1: HeuristicLab.Encodings.IntegerVectorEncoding.RoundedNormalAllPositionsManipulator.Apply(random, r, bounds, sigma); break;//FixedNormalAllPositionsManipulator.Apply(random, r, new RealVector(new[] { 0.1 })); break;
+          case 2: HeuristicLab.Encodings.IntegerVectorEncoding.UniformSomePositionsManipulator.Apply(random, r, bounds, 0.1); break;
           default: throw new NotImplementedException();
         }
@@ -108 +107 @@
       infillCriterion.RegressionSolution = model;
       infillCriterion.ExpensiveMaximization = expensiveMaximization;
-      infillCriterion.Encoding = Encoding;
+      infillCriterion.Encoding = GetRealVectorEncoding(Encoding);
       infillCriterion.Initialize();
     }
 
     #region helpers
-    private static bool InBounds(RealVector r, DoubleMatrix bounds) {
+    private static bool InBounds(IntegerVector r, IntMatrix bounds) {
       return !r.Where((t, i) => t < bounds[i % bounds.Rows, 0] || t > bounds[i % bounds.Rows, 1]).Any();
+    }
+
+    private static RealVectorEncoding GetRealVectorEncoding(IntegerVectorEncoding enc) {
+      var res = new RealVectorEncoding(enc.Length);
+      res.Bounds = new DoubleMatrix(enc.Bounds.Rows, enc.Bounds.Columns);
+      for (int r = 0; r < res.Bounds.Rows; r++)
+        for (int c = 0; c < res.Bounds.Columns; c++)
+          res.Bounds[r, c] = enc.Bounds[r, c];
+      return res;
+
+
     }
     #endregion

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/DiscreteEGO/DiscreteInfillSolver.cs

@@ -22 +22 @@
 using System;
 using System.Threading;
+using System.Linq;
+using System.Collections.Generic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -32 +34 @@
 
 namespace HeuristicLab.Algorithms.EGO {
-  /// <summary>
-  /// A base class for operators that manipulate real-valued vectors.
-  /// </summary>
-  [Item("InfillSolver", "A RealVectorCreator that creates candidates by optimizing an infill-subproblem")]
+  [Item("DiscreteInfillSolver", "An IntegerVectorCreator that creates candidates by optimizing an infill-subproblem")]
   [StorableClass]
-  public class InfillSolver : RealVectorCreator, ICancellableOperator {
+  public class DiscreteInfillSolver : IntegerVectorCreator, ICancellableOperator {
 
     public ILookupParameter<IAlgorithm> InfillOptimizationAlgorithmParamter => (ILookupParameter<IAlgorithm>)Parameters["InfillAlgorithm"];
@@ -44 +43 @@
     public ILookupParameter<BoolValue> RemoveDuplicatesParameter => (ILookupParameter<BoolValue>)Parameters["RemoveDuplicates"];
     public IFixedValueParameter<DoubleValue> DuplicateCutoffParameter => (IFixedValueParameter<DoubleValue>)Parameters["Duplicates Cutoff"];
-    public ILookupParameter<DoubleMatrix> InfillBoundsParameter => (ILookupParameter<DoubleMatrix>)Parameters["InfillBounds"];
+    public ILookupParameter<IntMatrix> InfillBoundsParameter => (ILookupParameter<IntMatrix>)Parameters["InfillBounds"];
 
     public CancellationToken Cancellation { get; set; }
 
     [StorableConstructor]
-    protected InfillSolver(bool deserializing) : base(deserializing) { }
-    protected InfillSolver(InfillSolver original, Cloner cloner) : base(original, cloner) { }
-    public InfillSolver() {
+    protected DiscreteInfillSolver(bool deserializing) : base(deserializing) { }
+    protected DiscreteInfillSolver(DiscreteInfillSolver original, Cloner cloner) : base(original, cloner) { }
+    public DiscreteInfillSolver() {
       Parameters.Add(new LookupParameter<IAlgorithm>("InfillAlgorithm", "The algorithm used to optimize the infill problem") { Hidden = true });
       Parameters.Add(new LookupParameter<IRegressionSolution>("Model", "The RegressionSolution upon which the InfillProblem operates") { Hidden = true });
@@ -57 +56 @@
       Parameters.Add(new LookupParameter<BoolValue>("RemoveDuplicates", "Whether duplicates shall be removed") { Hidden = true });
       Parameters.Add(new FixedValueParameter<DoubleValue>("Duplicates Cutoff", "The cut off radius for", new DoubleValue(0.01)) { Hidden = false });
-      Parameters.Add(new LookupParameter<DoubleMatrix>("InfillBounds", "The bounds applied for infill solving") { Hidden = true });
+      Parameters.Add(new LookupParameter<IntMatrix>("InfillBounds", "The bounds applied for infill solving") { Hidden = true });
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new InfillSolver(this, cloner);
+      return new DiscreteInfillSolver(this, cloner);
     }
 
-    protected override RealVector Create(IRandom random, IntValue length, DoubleMatrix bounds) {
+    protected override IntegerVector Create(IRandom random, IntValue length, IntMatrix bounds) {
       var infillBounds = InfillBoundsParameter.ActualValue;
       if (infillBounds != null && infillBounds.Rows > 0) {
@@ -75 +74 @@
       var res = OptimizeInfillProblem(alg, model, max, bounds, length.Value, random);
       var rad = DuplicateCutoffParameter.Value.Value;
-      if (!RemoveDuplicatesParameter.ActualValue.Value || !(GetMinDifference(model.ProblemData.Dataset, res) < rad * rad)) return res;
-      for (var i = 0; i < res.Length; i++) res[i] += random.NextDouble() * rad * 2;
+      if (!RemoveDuplicatesParameter.ActualValue.Value || GetMinDifference(model.ProblemData.Dataset, res) >= rad * rad) return res;
+
+      bool changed = false;
+      var steps = 0;
+      var dims = new List<int>();
+
+      //TODO this may take a long time to compute if many samples have already been evaluated in the surrounding area
+      //as the preferred region can not be sampled denser and denser due to the disceretization, the variance between two sampled points may be impossible to decease
+
+      //TODO speed up GetMinDifferecnce via tree-structure
+      while (!changed || GetMinDifference(model.ProblemData.Dataset, res) < rad * rad) {
+        if (dims.Count == 0) {
+          if (!changed && steps > 0) throw new ArgumentException("Can not avoid duplicate");
+          dims = Enumerable.Range(0, res.Length).ToList();
+          steps++;
+          changed = false;
+        }
+        var i = random.Next(dims.Count);
+        var dim = dims[i];
+        dims.RemoveAt(i);
+        var step = bounds[dim % bounds.Rows, 2] * steps;
+        var low = checkIntBounds(bounds, dim, res[dim] - step);
+        var high = checkIntBounds(bounds, dim, res[dim] + step);
+        if (!low && !high) continue;
+        else if (low && high) res[dim] += (random.NextDouble() < 0.5 ? -step : step);
+        else if (low) res[dim] -= step;
+        else res[dim] += step;
+        changed = true;
+      }
       return res;
     }
 
-    private RealVector OptimizeInfillProblem(IAlgorithm algorithm, IRegressionSolution model, bool maximization, DoubleMatrix bounds, int length, IRandom random) {
-      var infillProblem = algorithm.Problem as InfillProblem;
+
+    private bool checkIntBounds(IntMatrix b, int row, int value) {
+      var bi = row % b.Rows;
+      var l = b[bi, 0];
+      var h = b[bi, 1];
+      var s = b[bi, 2];
+      return l <= value && h >= value && (value - l) % s == 0;
+    }
+
+    private IntegerVector OptimizeInfillProblem(IAlgorithm algorithm, IRegressionSolution model, bool maximization, IntMatrix bounds, int length, IRandom random) {
+      var infillProblem = algorithm.Problem as DiscreteInfillProblem;
       if (infillProblem == null) throw new ArgumentException("The algortihm has no InfillProblem to solve");
       infillProblem.Encoding.Length = length;
@@ -87 +122 @@
       infillProblem.Initialize(model, maximization);
       var res = EgoUtilities.SyncRunSubAlgorithm(algorithm, random.Next(int.MaxValue), Cancellation);
-      var v = res[InfillProblem.BestInfillSolutionResultName].Value as RealVector;
+      var v = res[DiscreteInfillProblem.BestInfillSolutionResultName].Value as IntegerVector;
       algorithm.Runs.Clear();
       return v;
     }
 
-    private static double GetMinDifference(IDataset data, RealVector r) {
+    private static double GetMinDifference(IDataset data, IntegerVector r) {
       var mind = double.MaxValue;
       for (var i = 0; i < data.Rows; i++) {

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/DiscreteEGO/DiscreteSampleCollector.cs

@@ -23 +23 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
@@ -30 +30 @@
 
 namespace HeuristicLab.Algorithms.EGO {
-  /// <summary>
-  /// A base class for operators that manipulate real-valued vectors.
-  /// </summary>
-  [Item("SampleCollector", "Collects RealVectors into a modifiablbe dataset")]
+  [Item("DiscreteSampleCollector", "Collects IntegerVectors into a modifiablbe dataset")]
   [StorableClass]
-  public class SampleCollector : InstrumentedOperator {
+  public class DiscreteSampleCollector : InstrumentedOperator {
     public override bool CanChangeName => true;
 
-    public ILookupParameter<RealVector> RealVectorParameter => (ILookupParameter<RealVector>)Parameters["RealVector"];
+    public ILookupParameter<IntegerVector> IntegerVectorParameter => (ILookupParameter<IntegerVector>)Parameters["IntegerVector"];
     public ILookupParameter<DoubleValue> QualityParameter => (ILookupParameter<DoubleValue>)Parameters["Quality"];
     public ILookupParameter<ModifiableDataset> DatasetParameter => (ILookupParameter<ModifiableDataset>)Parameters["Dataset"];
 
     [StorableConstructor]
-    protected SampleCollector(bool deserializing) : base(deserializing) { }
-    protected SampleCollector(SampleCollector original, Cloner cloner) : base(original, cloner) { }
-    public SampleCollector() {
-      Parameters.Add(new LookupParameter<RealVector>("RealVector", "The vector which should be collected."));
+    protected DiscreteSampleCollector(bool deserializing) : base(deserializing) { }
+    protected DiscreteSampleCollector(DiscreteSampleCollector original, Cloner cloner) : base(original, cloner) { }
+    public DiscreteSampleCollector() {
+      Parameters.Add(new LookupParameter<IntegerVector>("IntegerVector", "The vector which should be collected."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality associated which this vector"));
       Parameters.Add(new LookupParameter<ModifiableDataset>("Dataset", "The Dataset in wich new samples are stored."));
@@ -52 +49 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SampleCollector(this, cloner);
+      return new DiscreteSampleCollector(this, cloner);
     }
 
     public sealed override IOperation InstrumentedApply() {
-      var vector = RealVectorParameter.ActualValue;
+      var vector = IntegerVectorParameter.ActualValue;
       var quality = QualityParameter.ActualValue.Value;
       var data = DatasetParameter.ActualValue;
@@ -71 +68 @@
 
 
-    private static void AddRow(ModifiableDataset data, RealVector vector, double quality) {
+    private static void AddRow(ModifiableDataset data, IntegerVector vector, double quality) {
       var row = new object[vector.Length + 1];
       for (var i = 0; i < vector.Length; i++)
-        row[i] = vector[i];
+        row[i] = (double)vector[i];
       row[vector.Length] = quality;
       data.AddRow(row);