Index: /trunk/sources/HeuristicLab.RealVector/BlendAlphaBetaCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/BlendAlphaBetaCrossover.cs	(revision 104)
+++ /trunk/sources/HeuristicLab.RealVector/BlendAlphaBetaCrossover.cs	(revision 104)
@@ -0,0 +1,103 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Core;
+using HeuristicLab.Evolutionary;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.RealVector {
+  public class BlendAlphaBetaCrossover : CrossoverBase {
+    public override string Description {
+      get { return
+@"Blend alpha-beta crossover for real vectors. Creates a new offspring by selecting a random value from the interval between the two alleles of the parent solutions. The interval is increased in both directions as follows: Into the direction of the 'better' solution by the factor alpha, into the direction of the 'worse' solution by the factor beta.
+Please use the operator BoundsChecker if necessary.";
+      }
+    }
+
+    public BlendAlphaBetaCrossover()
+      : base() {
+      AddVariableInfo(new VariableInfo("Maximization", "Maximization problem", typeof(BoolData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Quality", "Quality value", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("RealVector", "Parent and child real vector", typeof(DoubleArrayData), VariableKind.In | VariableKind.New));
+      VariableInfo alphaVarInfo = new VariableInfo("Alpha", "Value for alpha", typeof(DoubleData), VariableKind.In);
+      alphaVarInfo.Local = true;
+      AddVariableInfo(alphaVarInfo);
+      AddVariable(new Variable("Alpha", new DoubleData(0.75)));
+      VariableInfo betaVarInfo = new VariableInfo("Beta", "Value for beta", typeof(DoubleData), VariableKind.In);
+      betaVarInfo.Local = true;
+      AddVariableInfo(betaVarInfo);
+      AddVariable(new Variable("Beta", new DoubleData(0.25)));
+    }
+
+    public static double[] Apply(IRandom random, bool maximization, double[] parent1, double quality1, double[] parent2, double quality2, double alpha, double beta) {
+      int length = parent1.Length;
+      double[] result = new double[length];
+
+      for (int i = 0; i < length; i++) {
+        double interval = Math.Abs(parent1[i] - parent2[i]);
+
+        if ((maximization && (quality1 > quality2)) || ((!maximization) && (quality1 < quality2))) {
+          result[i] = SelectFromInterval(random, interval, parent1[i], parent2[i], alpha, beta);
+        } else {
+          result[i] = SelectFromInterval(random, interval, parent2[i], parent1[i], alpha, beta);
+        }
+      }
+      return result;
+    }
+
+    private static double SelectFromInterval(IRandom random, double interval, double val1, double val2, double alpha, double beta) {
+      double resMin = 0;
+      double resMax = 0;
+
+      if (val1 <= val2) {
+        resMin = val1 - interval * alpha;
+        resMax = val2 + interval * beta;
+      } else {
+        resMin = val2 - interval * beta;
+        resMax = val1 + interval * alpha;
+      }
+
+      return SelectRandomFromInterval(random, resMin, resMax);
+    }
+
+    private static double SelectRandomFromInterval(IRandom random, double resMin, double resMax) {
+      return resMin + random.NextDouble() * Math.Abs(resMax - resMin);
+    }
+
+    protected sealed override void Cross(IScope scope, IRandom random, IScope parent1, IScope parent2, IScope child) {
+      bool maximization = GetVariableValue<BoolData>("Maximization", scope, true).Data;
+      DoubleArrayData vector1 = parent1.GetVariableValue<DoubleArrayData>("RealVector", false);
+      DoubleData quality1 = parent1.GetVariableValue<DoubleData>("Quality", false);
+      DoubleArrayData vector2 = parent2.GetVariableValue<DoubleArrayData>("RealVector", false);
+      DoubleData quality2 = parent2.GetVariableValue<DoubleData>("Quality", false);
+      double alpha = GetVariableValue<DoubleData>("Alpha", scope, true).Data;
+      double beta = GetVariableValue<DoubleData>("Beta", scope, true).Data;
+
+      if (vector1.Data.Length != vector2.Data.Length) throw new InvalidOperationException("Cannot apply crossover to real vectors of different length.");
+
+      double[] result = Apply(random, maximization, vector1.Data, quality1.Data, vector2.Data, quality2.Data, alpha, beta);
+      child.AddVariable(new Variable(child.TranslateName("RealVector"), new DoubleArrayData(result)));
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.RealVector/BlendAlphaCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/BlendAlphaCrossover.cs	(revision 104)
+++ /trunk/sources/HeuristicLab.RealVector/BlendAlphaCrossover.cs	(revision 104)
@@ -0,0 +1,67 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.RealVector {
+  public class BlendAlphaCrossover : RealVectorCrossoverBase {
+    public override string Description {
+      get { return
+@"Blend alpha crossover for real vectors. Creates a new offspring by selecting a random value from the interval between the two alleles of the parent solutions. The interval is increased in both directions by the factor alpha.
+Please use the operator BoundsChecker if necessary.";
+      }
+    }
+
+    public BlendAlphaCrossover()
+      : base() {
+      VariableInfo alphaVarInfo = new VariableInfo("Alpha", "Value for alpha", typeof(DoubleData), VariableKind.In);
+      alphaVarInfo.Local = true;
+      AddVariableInfo(alphaVarInfo);
+      AddVariable(new Variable("Alpha", new DoubleData(0.5)));
+    }
+
+    public static double[] Apply(IRandom random, double[] parent1, double[] parent2, double alpha) {
+      int length = parent1.Length;
+      double[] result = new double[length];
+      double cMax = 0, cMin = 0, interval = 0, resMin = 0, resMax = 0;
+
+      for (int i = 0; i < length; i++) {
+        cMax = Math.Max(parent1[i], parent2[i]);
+        cMin = Math.Min(parent1[i], parent2[i]);
+        interval = Math.Abs(cMax - cMin);
+        resMin = cMin - interval * alpha;
+        resMax = cMax + interval * alpha;
+
+        result[i] = resMin + random.NextDouble() * Math.Abs(resMax - resMin);
+      }
+      return result;
+    }
+
+    protected override double[] Cross(IScope scope, IRandom random, double[] parent1, double[] parent2) {
+      double alpha = GetVariableValue<DoubleData>("Alpha", scope, true).Data;
+      return Apply(random, parent1, parent2, alpha);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.RealVector/BreederGeneticAlgorithmManipulator.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/BreederGeneticAlgorithmManipulator.cs	(revision 104)
+++ /trunk/sources/HeuristicLab.RealVector/BreederGeneticAlgorithmManipulator.cs	(revision 104)
@@ -0,0 +1,89 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.RealVector {
+  /// <summary>
+  /// Mühlenbein, Schlierkamp-Voosen (1993)
+  /// Predictive Models for the Breeder Genetic Algorithm I. Continuous Parameter Optimization
+  /// </summary>
+  public class BreederGeneticAlgorithmManipulator : RealVectorManipulatorBase {
+    public override string Description {
+      get {
+        return
+@"Breeder Genetic Algorithm Manipulator (Mühlenbein, Schlierkamp-Voosen, 1993). Changes one position of a real vector by adding/substracting a value of the interval [(2^-15)*range, ..., (2^0)*range], where range is SearchIntervalFactor * (max - min).
+
+Mühlenbein, Schlierkamp-Voosen (1993). Predictive Models for the Breeder Genetic Algorithm I. Continuous Parameter Optimization";
+      }
+    }
+
+    public BreederGeneticAlgorithmManipulator()
+      : base() {
+      AddVariableInfo(new VariableInfo("Minimum", "Minimum of the sampling range for the vector element (included)", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Maximum", "Maximum of the sampling range for the vector element (excluded)", typeof(DoubleData), VariableKind.In));
+      VariableInfo sifInfo = new VariableInfo("SearchIntervalFactor", "The factor determining the size of the search interval, that will be added/removed to/from the allele selected for manipulation.", typeof(DoubleData), VariableKind.In);
+      sifInfo.Local = true;
+      AddVariableInfo(sifInfo);
+      AddVariable(new Variable("SearchIntervalFactor", new DoubleData(0.1)));
+    }
+
+    public static double[] Apply(IScope scope, IRandom random, double[] vector, double min, double max, double searchIntervalFactor) {
+      int length = vector.Length;
+      int pos = random.Next(length);
+      double range = searchIntervalFactor * (max - min);
+      double value = range * Sigma(random);
+
+      if (random.NextDouble() < 0.5) {
+        vector[pos] = vector[pos] + value;
+      } else {
+        vector[pos] = vector[pos] - value;
+      }
+
+      return vector;
+    }
+
+    private static double Sigma(IRandom random) {
+      double sigma = 0;
+      int limit = 16;
+
+      for (int i = 0; i < limit; i++) {
+        if (random.Next(limit) == 15) {
+          // execute this statement with a probability of 1/16
+          sigma += Math.Pow(2, -i);
+        }
+      }
+
+      return sigma;
+    }
+
+    protected override double[] Manipulate(IScope scope, IRandom random, double[] vector) {
+      double min = GetVariableValue<DoubleData>("Minimum", scope, true).Data;
+      double max = GetVariableValue<DoubleData>("Maximum", scope, true).Data;
+      double searchIntervalFactor = GetVariableValue<DoubleData>("SearchIntervalFactor", scope, true).Data;
+      return Apply(scope, random, vector, min, max, searchIntervalFactor);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.RealVector/HeuristicLab.RealVector.csproj
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/HeuristicLab.RealVector.csproj	(revision 103)
+++ /trunk/sources/HeuristicLab.RealVector/HeuristicLab.RealVector.csproj	(revision 104)
@@ -40,4 +40,7 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BlendAlphaBetaCrossover.cs" />
+    <Compile Include="BlendAlphaCrossover.cs" />
+    <Compile Include="BreederGeneticAlgorithmManipulator.cs" />
     <Compile Include="ContinuousCrossover.cs" />
     <Compile Include="CompleteContinuousCrossover.cs" />
@@ -46,4 +49,6 @@
     <Compile Include="HeuristicCrossover.cs" />
     <Compile Include="IntermediateRecombination.cs" />
+    <Compile Include="MichalewiczNonUniformAllPositionsManipulator.cs" />
+    <Compile Include="MichalewiczNonUniformOnePositionManipulator.cs" />
     <Compile Include="RandomConvexCrossover.cs" />
     <Compile Include="LocalCrossover.cs" />
Index: /trunk/sources/HeuristicLab.RealVector/MichalewiczNonUniformAllPositionsManipulator.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/MichalewiczNonUniformAllPositionsManipulator.cs	(revision 104)
+++ /trunk/sources/HeuristicLab.RealVector/MichalewiczNonUniformAllPositionsManipulator.cs	(revision 104)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.RealVector {
+  public class MichalewiczNonUniformAllPositionsManipulator : RealVectorManipulatorBase {
+    public override string Description {
+      get { return
+@"Non-uniformly distributed change of all positions of a real vector (Michalewicz 1992)
+Initially, the space will be searched uniformly and very locally at later stages. This increases the probability of generating the new number closer to its successor instead of a random number.
+
+Michalewicz, Z. (1992). Genetic Algorithms + Data Structures = Evolution Programs. Springer Verlag.";
+      }
+    }
+
+    public MichalewiczNonUniformAllPositionsManipulator()
+      : base() {
+      AddVariableInfo(new VariableInfo("Minimum", "Minimum of the sampling range for the vector element (included)", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Maximum", "Maximum of the sampling range for the vector element (excluded)", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("CurrentGeneration", "Current Generation of the algorithm", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("MaximumGenerations", "Maximum number of Generations", typeof(IntData), VariableKind.In));
+      VariableInfo genDepInfo = new VariableInfo("GenerationsDependency", "Specifies the degree of dependency on the number of generations", typeof(IntData), VariableKind.In);
+      genDepInfo.Local = true;
+      AddVariableInfo(genDepInfo);
+      AddVariable(new Variable("GenerationsDependency", new IntData(5)));
+    }
+
+    protected override double[] Manipulate(IScope scope, IRandom random, double[] vector) {
+      double min = GetVariableValue<DoubleData>("Minimum", scope, true).Data;
+      double max = GetVariableValue<DoubleData>("Maximum", scope, true).Data;
+      int currentGeneration = GetVariableValue<IntData>("CurrentGeneration", scope, true).Data;
+      int maximumGenerations = GetVariableValue<IntData>("MaximumGenerations", scope, true).Data;
+      int generationsDependency = GetVariableValue<IntData>("GenerationsDependency", scope, true).Data;
+      return Apply(random, vector, min, max, currentGeneration, maximumGenerations, generationsDependency);
+    }
+
+    public static double[] Apply(IRandom random, double[] vector, double min, double max, int currentGeneration, int maximumGenerations, int generationsDependency) {
+      int length = vector.Length;
+      double[] result = new double[length];
+
+      for (int i = 0; i < length; i++) {
+        if (random.NextDouble() < 0.5) {
+          vector[i] = vector[i] + Delta(random, currentGeneration, max - vector[i], maximumGenerations, generationsDependency);
+        } else {
+          vector[i] = vector[i] - Delta(random, currentGeneration, vector[i] - min, maximumGenerations, generationsDependency);
+        }
+      }
+
+      return vector;
+    }
+
+    // returns a value between 0 and y (both included)
+    private static double Delta(IRandom random, int currentGeneration, double y, int maximumGenerations, int generationsDependency) {
+      return y * (1 - Math.Pow(random.NextDouble(), Math.Pow(1 - currentGeneration / maximumGenerations, generationsDependency)));
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.RealVector/MichalewiczNonUniformOnePositionManipulator.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/MichalewiczNonUniformOnePositionManipulator.cs	(revision 104)
+++ /trunk/sources/HeuristicLab.RealVector/MichalewiczNonUniformOnePositionManipulator.cs	(revision 104)
@@ -0,0 +1,79 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.RealVector {
+  public class MichalewiczNonUniformOnePositionManipulator : RealVectorManipulatorBase {
+    public override string Description {
+      get { return
+@"Non-uniformly distributed change of one position of a real vector (Michalewicz 1992)
+Initially, the space will be searched uniformly and very locally at later stages. This increases the probability of generating the new number closer to its successor instead of a random number.
+
+Michalewicz, Z. (1992). Genetic Algorithms + Data Structures = Evolution Programs. Springer Verlag.";
+      }
+    }
+
+    public MichalewiczNonUniformOnePositionManipulator()
+      : base() {
+      AddVariableInfo(new VariableInfo("Minimum", "Minimum of the sampling range for the vector element (included)", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Maximum", "Maximum of the sampling range for the vector element (excluded)", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("CurrentGeneration", "Current Generation of the algorithm", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("MaximumGenerations", "Maximum number of Generations", typeof(IntData), VariableKind.In));
+      VariableInfo genDepInfo = new VariableInfo("GenerationsDependency", "Specifies the degree of dependency on the number of generations", typeof(IntData), VariableKind.In);
+      genDepInfo.Local = true;
+      AddVariableInfo(genDepInfo);
+      AddVariable(new Variable("GenerationsDependency", new IntData(5)));
+    }
+
+    protected override double[] Manipulate(IScope scope, IRandom random, double[] vector) {
+      double min = GetVariableValue<DoubleData>("Minimum", scope, true).Data;
+      double max = GetVariableValue<DoubleData>("Maximum", scope, true).Data;
+      int currentGeneration = GetVariableValue<IntData>("CurrentGeneration", scope, true).Data;
+      int maximumGenerations = GetVariableValue<IntData>("MaximumGenerations", scope, true).Data;
+      int generationsDependency = GetVariableValue<IntData>("GenerationsDependency", scope, true).Data;
+      return Apply(random, vector, min, max, currentGeneration, maximumGenerations, generationsDependency);
+    }
+
+    public static double[] Apply(IRandom random, double[] vector, double min, double max, int currentGeneration, int maximumGenerations, int generationsDependency) {
+      int length = vector.Length;
+      double[] result = new double[length];
+      int pos = random.Next(length);
+
+      if (random.NextDouble() < 0.5) {
+        vector[pos] = vector[pos] + Delta(random, currentGeneration, max - vector[pos], maximumGenerations, generationsDependency);
+      } else {
+        vector[pos] = vector[pos] - Delta(random, currentGeneration, vector[pos] - min, maximumGenerations, generationsDependency);
+      }
+
+      return vector;
+    }
+
+    // returns a value between 0 and y (both included)
+    private static double Delta(IRandom random, int currentGeneration, double y, int maximumGenerations, int generationsDependency) {
+      return y * (1 - Math.Pow(random.NextDouble(), Math.Pow(1 - currentGeneration / maximumGenerations, generationsDependency)));
+    }
+  }
+}
