Changeset 5337 for branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3

Timestamp:

01/20/11 01:30:44 (14 years ago)

Author:

cneumuel

Message:

#1215

• made all IAlgorithm types compatible to be loaded into MetaOptimization.
• valid problem types are now automatically set

Location:

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3

Files:

• Analyzers/BestParameterConfigurationAnalyzer.cs (modified) (2 diffs)
• Analyzers/ReferenceQualityAnalyzer.cs (modified) (2 diffs)
• Analyzers/RunsAnalyzer.cs (modified) (2 diffs)
• ConstrainedTypeValue.cs (modified) (3 diffs)
• Encoding/ParameterConfigurationTree.cs (modified) (1 diff)
• Encoding/ParameterConfigurations/ParameterConfiguration.cs (modified) (2 diffs)
• Encoding/RangeConstraints/DoubleValueRange.cs (modified) (2 diffs)
• Encoding/RangeConstraints/IntValueRange.cs (modified) (1 diff)
• Encoding/RangeConstraints/PercentValueRange.cs (modified) (2 diffs)
• Evaluators/AlgorithmExecutor.cs (modified) (1 diff)
• Evaluators/ParameterConfigurationEvaluator.cs (modified) (6 diffs)
• MetaOptimizationProblem.cs (modified) (6 diffs)
• Operators/Crossovers/AverageDoubleValueCrossover.cs (modified) (1 diff)
• Operators/Crossovers/NormalDoubleValueCrossover.cs (modified) (1 diff)
• Operators/Crossovers/NormalIntValueCrossover.cs (modified) (1 diff)
• Operators/Manipulators/NormalDoubleValueManipulator.cs (modified) (1 diff)
• Operators/Manipulators/NormalIntValueManipulator.cs (modified) (1 diff)
• Operators/Manipulators/UniformDoubleValueManipulator.cs (modified) (1 diff)
• Operators/Manipulators/UniformIntValueManipulator.cs (modified) (1 diff)

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs

@@ -42 +42 @@
       get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityReferences"]; }
     }
-    public LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
-      get { return (LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
+    public LookupParameter<ConstrainedItemList<IProblem>> ProblemsParameter {
+      get { return (LookupParameter<ConstrainedItemList<IProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
     }
 
@@ -56 +56 @@
       Parameters.Add(new LookupParameter<RunCollection>("Population", ""));
       Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityReferences", ""));
-      Parameters.Add(new LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>(MetaOptimizationProblem.ProblemsParameterName));
+      Parameters.Add(new LookupParameter<ConstrainedItemList<IProblem>>(MetaOptimizationProblem.ProblemsParameterName));
     }
 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/ReferenceQualityAnalyzer.cs

@@ -30 +30 @@
       get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityReferences"]; }
     }
-    public LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
-      get { return (LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
+    public LookupParameter<ConstrainedItemList<IProblem>> ProblemsParameter {
+      get { return (LookupParameter<ConstrainedItemList<IProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
     }
 
@@ -40 +40 @@
       Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", ""));
       Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityReferences", ""));
-      Parameters.Add(new LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>(MetaOptimizationProblem.ProblemsParameterName, ""));
+      Parameters.Add(new LookupParameter<ConstrainedItemList<IProblem>>(MetaOptimizationProblem.ProblemsParameterName, ""));
     }
 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/RunsAnalyzer.cs

@@ -30 +30 @@
       get { return (LookupParameter<DoubleArray>)Parameters["ProblemQualityReferences"]; }
     }
-    public LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
-      get { return (LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
+    public LookupParameter<ConstrainedItemList<IProblem>> ProblemsParameter {
+      get { return (LookupParameter<ConstrainedItemList<IProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
     }
     public ValueLookupParameter<ItemDictionary<StringValue, RunCollection>> RunsParameter {
@@ -43 +43 @@
       Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", ""));
       Parameters.Add(new LookupParameter<DoubleArray>("ProblemQualityReferences", ""));
-      Parameters.Add(new LookupParameter<ConstrainedItemList<ISingleObjectiveProblem>>(MetaOptimizationProblem.ProblemsParameterName, ""));
+      Parameters.Add(new LookupParameter<ConstrainedItemList<IProblem>>(MetaOptimizationProblem.ProblemsParameterName, ""));
       Parameters.Add(new ValueLookupParameter<ItemDictionary<StringValue, RunCollection>>("Runs", "", new ItemDictionary<StringValue, RunCollection>()));
     }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/ConstrainedTypeValue.cs

@@ -13 +13 @@
   [Item("ConstrainedTypeValue", "Represents a type with constraints.")]
   [StorableClass]
-  public abstract class ConstrainedTypeValue : TypeValue {
+  public class ConstrainedTypeValue : TypeValue {
 
     [Storable]
@@ -42 +42 @@
       this.validTypes = new List<Type>(original.validTypes);
     }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConstrainedTypeValue(this, cloner);
+    }
   }
 
@@ -56 +59 @@
       this.Value = value;
     }
+    [StorableConstructor]
+    protected ConstrainedTypeValue(bool deserializing) : base(deserializing) { }
     protected ConstrainedTypeValue(ConstrainedTypeValue original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterConfigurationTree.cs

@@ -113 +113 @@
 
     #region constructors and cloning
-    public ParameterConfigurationTree(EngineAlgorithm algorithm)
+    public ParameterConfigurationTree(IAlgorithm algorithm)
       : base(null, algorithm.GetType()) {
       this.Optimize = true; // root must always be optimized

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterConfigurations/ParameterConfiguration.cs

@@ -217 +217 @@
     }
 
-    private IEnumerable<Type> GetValidTypes(IValueParameter parameter) {
+    private static IEnumerable<Type> GetValidTypes(IValueParameter parameter) {
       // in case of IOperator return empty list, otherwise hundreds of types would be returned. this mostly occurs for Successor which will never be optimized
       if (parameter.DataType == typeof(IOperator))
         return new List<Type>();
 
+      // return only one type for ValueTypeValues<> (Int, Double, Percent, Bool). Otherwise 2 types would be returned for DoubleValue (PercentValue which is derived)
+      if (IsSubclassOfRawGeneric(typeof(ValueTypeValue<>), parameter.DataType))
+        return new List<Type> { parameter.DataType }; 
+      
       if (IsSubclassOfRawGeneric(typeof(OptionalConstrainedValueParameter<>), parameter.GetType())) {
+        // use existing validvalues if known
         var parameterValidValues = (IEnumerable)parameter.GetType().GetProperty("ValidValues").GetValue(parameter, new object[] { });
         return parameterValidValues.Cast<object>().Select(x => x.GetType());
       } else {
-        return ApplicationManager.Manager.GetTypes(valueDataType, true);
+        // otherwise use all assignable types
+        return ApplicationManager.Manager.GetTypes(parameter.DataType, true);
       }
     }
@@ -273 +279 @@
           return true;
         }
-        toCheck = toCheck.BaseType;
+        toCheck = toCheck.BaseType; // baseType is null when toCheck is an Interface
+        if (toCheck == null)
+          return false;
       }
       return false;

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/DoubleValueRange.cs

@@ -29 +29 @@
     }
 
-    public void ApplyStepSize(DoubleValue value) {
-      value.Value = ((int)Math.Round(value.Value / this.StepSize.Value, 0)) * this.StepSize.Value;
+    public double ApplyStepSize(double value) {
+      return (Math.Round(value / this.StepSize.Value, 0)) * this.StepSize.Value;
     }
 
@@ -44 +44 @@
         solutions.Add(new DoubleValue(value));
         value += StepSize.Value;
+        value = ApplyStepSize(value);
       }
       return solutions;

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/IntValueRange.cs

@@ -29 +29 @@
     }
 
-    public void ApplyStepSize(IntValue value) {
-      value.Value = ((int)Math.Round(value.Value / (double)this.StepSize.Value, 0)) * this.StepSize.Value;
+    public int ApplyStepSize(int value) {
+      return ((int)Math.Round(value / (double)this.StepSize.Value, 0)) * this.StepSize.Value;
     }
 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/PercentValueRange.cs

@@ -33 +33 @@
     }
 
-    public void ApplyStepSize(PercentValue value) {
-      value.Value = ((int)Math.Round(value.Value / this.StepSize.Value, 0)) * this.StepSize.Value;
+    public double ApplyStepSize(double value) {
+      return ((int)Math.Round(value / this.StepSize.Value, 0)) * this.StepSize.Value;
     }
 
@@ -48 +48 @@
         solutions.Add(new PercentValue(value));
         value += StepSize.Value;
+        value = ApplyStepSize(value);
       }
       return solutions;

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/AlgorithmExecutor.cs

@@ -11 +11 @@
   /// </summary>
   public class AlgorithmExecutor {
-    private EngineAlgorithm algorithm;
+    private IAlgorithm algorithm;
     private AutoResetEvent waitHandle = new AutoResetEvent(false);
 
-    public AlgorithmExecutor(EngineAlgorithm algorithm) {
+    public AlgorithmExecutor(IAlgorithm algorithm) {
       this.algorithm = algorithm;
     }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/ParameterConfigurationEvaluator.cs

@@ -30 +30 @@
       get { return (ILookupParameter<TypeValue>)Parameters[MetaOptimizationProblem.AlgorithmTypeParameterName]; }
     }
-    public ILookupParameter<IItemList<ISingleObjectiveProblem>> ProblemsParameter {
-      get { return (ILookupParameter<IItemList<ISingleObjectiveProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
+    public ILookupParameter<IItemList<IProblem>> ProblemsParameter {
+      get { return (ILookupParameter<IItemList<IProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
     }
     public ILookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
@@ -58 +58 @@
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the ParameterVector."));
       Parameters.Add(new LookupParameter<TypeValue>(MetaOptimizationProblem.AlgorithmTypeParameterName, "Missing description."));
-      Parameters.Add(new LookupParameter<IItemList<ISingleObjectiveProblem>>(MetaOptimizationProblem.ProblemsParameterName, "Missing description."));
+      Parameters.Add(new LookupParameter<IItemList<IProblem>>(MetaOptimizationProblem.ProblemsParameterName, "Missing description."));
       Parameters.Add(new LookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "Missing description."));
       Parameters.Add(new LookupParameter<IntValue>(MetaOptimizationProblem.RepetitionsParameterName, "Number of evaluations on one problem."));
@@ -77 +77 @@
     public override IOperation Apply() {
       ParameterConfigurationTree parameterConfiguration = ParameterConfigurationParameter.ActualValue;
-      EngineAlgorithm algorithm = (EngineAlgorithm)Activator.CreateInstance(AlgorithmTypeParameter.ActualValue.Value);
-      IItemList<ISingleObjectiveProblem> problems = ProblemsParameter.ActualValue;
+      IAlgorithm algorithm = (IAlgorithm)Activator.CreateInstance(AlgorithmTypeParameter.ActualValue.Value);
+      IItemList<IProblem> problems = ProblemsParameter.ActualValue;
       ItemDictionary<StringValue, RunCollection> runsCache = ResultsParameter.ActualValue.ContainsKey("Runs") ? (ItemDictionary<StringValue, RunCollection>)ResultsParameter.ActualValue["Runs"].Value : null;
       double[] referenceQualities = GetReferenceQualities(problems);
@@ -113 +113 @@
     }
 
-    private double[] GetReferenceQualities(IItemList<ISingleObjectiveProblem> problems) {
+    private double[] GetReferenceQualities(IItemList<IProblem> problems) {
       double[] referenceQualities;
       if (ProblemQualityReferencesParameter.ActualValue == null) {
@@ -127 +127 @@
     }
 
-    private RunCollection ExecuteAlgorithm(ParameterConfigurationTree parameterConfiguration, EngineAlgorithm algorithm, IItemList<ISingleObjectiveProblem> problems) {
-      EngineAlgorithm algorithmClone = (EngineAlgorithm)algorithm.Clone();
+    private RunCollection ExecuteAlgorithm(ParameterConfigurationTree parameterConfiguration, IAlgorithm algorithm, IItemList<IProblem> problems) {
+      IAlgorithm algorithmClone = (IAlgorithm)algorithm.Clone();
 
       // set parameters
@@ -134 +134 @@
       algorithmClone.StoreAlgorithmInEachRun = false;
 
-      algorithmClone.Engine = new SequentialEngine.SequentialEngine();
+      if (algorithmClone is EngineAlgorithm) {
+        ((EngineAlgorithm)algorithmClone).Engine = new SequentialEngine.SequentialEngine();
+      }
       algorithmClone.Prepare(true);
 
-      foreach (ISingleObjectiveProblem problem in problems) {
+      foreach (IProblem problem in problems) {
         algorithmClone.Problem = (IProblem)problem.Clone();
 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs

@@ -49 +49 @@
 
     #region Parameter Properties
-    public IValueParameter<ConstrainedTypeValue<EngineAlgorithm>> AlgorithmTypeParameter {
-      get { return (ValueParameter<ConstrainedTypeValue<EngineAlgorithm>>)Parameters[AlgorithmTypeParameterName]; }
-    }
-    public IValueParameter<ConstrainedTypeValue<ISingleObjectiveProblem>> ProblemTypeParameter {
-      get { return (ValueParameter<ConstrainedTypeValue<ISingleObjectiveProblem>>)Parameters[ProblemTypeParameterName]; }
-    }
-    public IValueParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
-      get { return (ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[ProblemsParameterName]; }
+    public IValueParameter<ConstrainedTypeValue<IAlgorithm>> AlgorithmTypeParameter {
+      get { return (ValueParameter<ConstrainedTypeValue<IAlgorithm>>)Parameters[AlgorithmTypeParameterName]; }
+    }
+    public IValueParameter<ConstrainedTypeValue<IProblem>> ProblemTypeParameter {
+      get { return (ValueParameter<ConstrainedTypeValue<IProblem>>)Parameters[ProblemTypeParameterName]; }
+    }
+    public IValueParameter<ConstrainedItemList<IProblem>> ProblemsParameter {
+      get { return (ValueParameter<ConstrainedItemList<IProblem>>)Parameters[ProblemsParameterName]; }
     }
     public IValueParameter<ParameterConfigurationTree> ParameterConfigurationTreeParameter {
@@ -75 +75 @@
 
     #region Properties
-    public EngineAlgorithm Algorithm {
+    public IAlgorithm Algorithm {
       get { return CreateAlgorithm(AlgorithmType.Value, ProblemType.Value); }
     }
-    public ConstrainedTypeValue<EngineAlgorithm> AlgorithmType {
+    public ConstrainedTypeValue<IAlgorithm> AlgorithmType {
       get { return AlgorithmTypeParameter.Value; }
       set { AlgorithmTypeParameter.Value = value; }
     }
-    public ConstrainedTypeValue<ISingleObjectiveProblem> ProblemType {
+    public ConstrainedTypeValue<IProblem> ProblemType {
       get { return ProblemTypeParameter.Value; }
       set { ProblemTypeParameter.Value = value; }
     }
-    public ConstrainedItemList<ISingleObjectiveProblem> Problems {
+    public ConstrainedItemList<IProblem> Problems {
       get { return ProblemsParameter.Value; }
       set { ProblemsParameter.Value = value; }
@@ -111 +111 @@
     public MetaOptimizationProblem()
       : base() {
-      Parameters.Add(new ValueParameter<ConstrainedTypeValue<EngineAlgorithm>>(AlgorithmTypeParameterName, "The algorithm which's parameters should be optimized.", new ConstrainedTypeValue<EngineAlgorithm>(typeof(GeneticAlgorithm))));
-      Parameters.Add(new ValueParameter<ConstrainedTypeValue<ISingleObjectiveProblem>>(ProblemTypeParameterName, "The problem type.", new ConstrainedTypeValue<ISingleObjectiveProblem>(typeof(SingleObjectiveTestFunctionProblem))));
-      Parameters.Add(new ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ConstrainedItemList<ISingleObjectiveProblem>()));
+      Parameters.Add(new ValueParameter<ConstrainedTypeValue<IAlgorithm>>(AlgorithmTypeParameterName, "The algorithm which's parameters should be optimized.", new ConstrainedTypeValue<IAlgorithm>(typeof(GeneticAlgorithm))));
+      Parameters.Add(new ValueParameter<ConstrainedTypeValue<IProblem>>(ProblemTypeParameterName, "The problem type.", new ConstrainedTypeValue<IProblem>()));
+      Parameters.Add(new ValueParameter<ConstrainedItemList<IProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ConstrainedItemList<IProblem>()));
       Parameters.Add(new ValueParameter<ParameterConfigurationTree>(ParameterConfigurationTreeParameterName, "Tree of algorithm parameters that should be optimized."));
       Parameters.Add(new ValueParameter<IntValue>(RepetitionsParameterName, "The number of evaluations for each problem.", new IntValue(3)));
@@ -137 +137 @@
       ParameterizeOperators();
 
-      ProblemTypeParameter_ValueChanged(this, EventArgs.Empty);
+      AlgorithmTypeParameter_ValueChanged(this, EventArgs.Empty);
     }
 
@@ -222 +222 @@
 
     private void AlgorithmType_ValueChanged(object sender, EventArgs e) {
+      IAlgorithm instance = (IAlgorithm)Activator.CreateInstance(AlgorithmType.Value);
+      this.ProblemType.ValidTypes = ApplicationManager.Manager.GetTypes(instance.ProblemType, true).ToList();
+      this.ProblemType.Value = this.ProblemType.ValidTypes.First();
       ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(CreateAlgorithm(AlgorithmType.Value, ProblemType.Value));
     }
@@ -236 +239 @@
     #endregion
 
-    private EngineAlgorithm CreateAlgorithm(Type algorithmType, Type problemType) {
-      EngineAlgorithm algorithm = (EngineAlgorithm)Activator.CreateInstance(algorithmType);
+    private IAlgorithm CreateAlgorithm(Type algorithmType, Type problemType) {
+      IAlgorithm algorithm = (IAlgorithm)Activator.CreateInstance(algorithmType);
       algorithm.Problem = (IProblem)Activator.CreateInstance(problemType);
       return algorithm;
     }
 
-    public void ImportAlgorithm(EngineAlgorithm algorithm) {
+    public void ImportAlgorithm(IAlgorithm algorithm) {
       AlgorithmType.Value = algorithm.GetType();
-      if(algorithm.Problem != null) ProblemType.Value = algorithm.Problem.GetType();
+      if (algorithm.Problem != null) ProblemType.Value = algorithm.Problem.GetType();
       ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(algorithm);
-      if(algorithm.Problem != null) Problems.Add((ISingleObjectiveProblem)algorithm.Problem);
+      if (algorithm.Problem != null) Problems.Add((IProblem)algorithm.Problem);
     }
   }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/AverageDoubleValueCrossover.cs

@@ -34 +34 @@
     public static void ApplyStatic(IRandom random, DoubleValue value, DoubleValue other, DoubleValueRange range) {
       value.Value = (value.Value + other.Value) / 2;
-      range.ApplyStepSize(value);
+      value.Value = range.ApplyStepSize(value.Value);
     }
   }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalDoubleValueCrossover.cs

@@ -39 +39 @@
       do {
         offspring.Value = N.NextDouble();
-        range.ApplyStepSize(offspring);
+        offspring.Value = range.ApplyStepSize(offspring.Value);
       } while (!range.IsInRange(offspring.Value));
       return offspring;

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Crossovers/NormalIntValueCrossover.cs

@@ -38 +38 @@
       do {
         offspring.Value = (int)N.NextDouble();
-        range.ApplyStepSize(offspring);
+        offspring.Value = range.ApplyStepSize(offspring.Value);
       } while (!range.IsInRange(offspring.Value));
       return offspring;

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalDoubleValueManipulator.cs

@@ -45 +45 @@
         NormalAllPositionsManipulator.Apply(random, vector, strategy);
         value.Value = vector[0];
-        range.ApplyStepSize(value);
+        value.Value = range.ApplyStepSize(value.Value);
         ok = range.IsInRange(value.Value);
       }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/NormalIntValueManipulator.cs

@@ -47 +47 @@
         NormalAllPositionsManipulator.Apply(random, vector, strategy);
         value.Value = (int)vector[0];
-        range.ApplyStepSize(value);
+        value.Value = range.ApplyStepSize(value.Value);
         ok = range.IsInRange(value.Value);
       }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformDoubleValueManipulator.cs

@@ -47 +47 @@
         UniformOnePositionManipulator.Apply(random, vector, bounds);
         value.Value = vector[0];
-        range.ApplyStepSize(value);
+        value.Value = range.ApplyStepSize(value.Value);
         ok = range.IsInRange(value.Value);
       }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Operators/Manipulators/UniformIntValueManipulator.cs

@@ -45 +45 @@
         UniformOnePositionManipulator.Apply(random, vector, range.LowerBound, new IntValue(range.UpperBound.Value + 1));
         value.Value = vector[0];
-        range.ApplyStepSize(value);
+        value.Value = range.ApplyStepSize(value.Value);
         ok = range.IsInRange(value.Value);
       }