Context Navigation

HeuristicLab.Encodings.IntegerVectorEncoding

Timestamp:

10/11/12 13:37:56 (12 years ago)

Author:

abeham

Message:

#1969: Made sure max is exclusive and always a feasible value (a multiple of step + min)

Location:

Files:

r8019	r8790
67	67	int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
68	68	if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
	69	max = FloorFeasible(min, max, step, max - 1);
69	70	result[i] = RoundFeasible(min, max, step, avg);
70	71	}

-                      r8019
+                      r8790
       if (beta.Value < 0) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Parameter beta must be greater or equal to 0.", "beta");
       if (bounds == null || bounds.Rows < 1 || bounds.Columns < 2) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Invalid bounds specified.", "bounds");
       int length = betterParent.Length;
       double min, max, d;
 …
         maxBound = bounds[i % bounds.Rows, 1];
         if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+        maxBound = FloorFeasible(minBound, maxBound, step, maxBound - 1);
         d = Math.Abs(betterParent[i] - worseParent[i]);

-                      r8019
+                      r8790
       var result = new IntegerVector(length);
       double max = 0, min = 0, d = 0, resMin = 0, resMax = 0;
       int minBounds, maxBounds, step = 1;
+      int minBound, maxBound, step = 1;
       for (int i = 0; i < length; i++) {
         minBounds = bounds[i % bounds.Rows, 0];
         maxBounds = bounds[i % bounds.Rows, 1];
+        minBound = bounds[i % bounds.Rows, 0];
+        maxBound = bounds[i % bounds.Rows, 1];
         if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+        maxBound = FloorFeasible(minBound, maxBound, step, maxBound - 1);
         max = Math.Max(parent1[i], parent2[i]);
         min = Math.Min(parent1[i], parent2[i]);
         d = Math.Abs(max - min);
         resMin = FloorFeasible(minBounds, maxBounds, step, min - d * alpha.Value);
         resMax = CeilingFeasible(minBounds, maxBounds, step, max + d * alpha.Value);
+        resMin = FloorFeasible(minBound, maxBound, step, min - d * alpha.Value);
+        resMax = CeilingFeasible(minBound, maxBound, step, max + d * alpha.Value);
         result[i] = RoundFeasible(minBounds, maxBounds, step, resMin + random.NextDouble() * Math.Abs(resMax - resMin));
+        result[i] = RoundFeasible(minBound, maxBound, step, resMin + random.NextDouble() * Math.Abs(resMax - resMin));
+      }
       return result;

r8019	r8790
88	88	max = bounds[i % bounds.Rows, 1];
89	89	if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
	90	max = FloorFeasible(min, max, step, max - 1);
90	91	result[i] = RoundFeasible(min, max, step, betterParent[i] + factor * (betterParent[i] - worseParent[i]));
91	92	}

r8019	r8790
64	64	max = bounds[i % bounds.Rows, 1];
65	65	if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
	66	max = FloorFeasible(min, max, step, max - 1);
66	67	factor = random.NextDouble();
67	68	result[i] = RoundFeasible(min, max, step, (factor * parent1[i]) + ((1 - factor) * parent2[i]));

r8019	r8790
85	85	int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
86	86	if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
	87	max = FloorFeasible(min, max, step, max - 1);
87	88	double value = alpha.Value * parent1[i] + (1 - alpha.Value) * parent2[i];
88	89	result[i] = RoundFeasible(min, max, step, value);

r8019	r8790
76	76
77	77	int value = (vector[i] + (int)Math.Round((N.NextDouble() * sigma[i % sigma.Length])) - min) / step;
	78	max = FloorFeasible(min, max, step, max - 1);
78	79	vector[i] = RoundFeasible(min, max, step, value);
79	80	}

r8019	r8790
86	86
87	87	int value = (vector[i] + (int)Math.Round((N.NextDouble() * strategyParameters[i % strategyParameters.Length])) - min) / step;
	88	max = FloorFeasible(min, max, step, max - 1);
88	89	vector[i] = RoundFeasible(min, max, step, value);
89	90	}

-                      r8019
+                      r8790
       if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("UniformOnePositionManipulator: Invalid bounds specified", "bounds");
       int min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1], step = 1;
+      if (bounds.Columns > 2) step = bounds[index % bounds.Rows, 2];
+      vector[index] = RoundFeasible(min, max, step, random.Next(min, max + 1));
+      if (min == max) {
+        vector[index] = min;
+      } else {
+        if (bounds.Columns > 2) step = bounds[index % bounds.Rows, 2];
+        // max has to be rounded to the lower feasible value
+        // e.g. min...max / step = 0...100 / 5, max is exclusive so it would be 0..99
+        // but 99 is not a feasible value, so max needs to be adjusted => min = 0, max = 95
+        max = FloorFeasible(min, max, step, max - 1);
+        vector[index] = RoundFeasible(min, max, step, random.Next(min, max));
+      }
+    }

Note: See TracChangeset for help on using the changeset viewer.