Ejemplo n.º 1
1
 protected AdditiveMove(AdditiveMove original, Cloner cloner)
   : base(original, cloner) {
   this.Dimension = original.Dimension;
   this.MoveDistance = original.MoveDistance;
   if (original.RealVector != null)
     this.RealVector = cloner.Clone(original.RealVector);
 }
Ejemplo n.º 2
0
 public double[] CheckConstraints(RealVector r, int objectives) {
   if (r.Length < 10 * objectives) throw new Exception("The dimensionality of the problem(ProblemSize) must be larger than ten times the number of objectives ");
   double n = r.Length;
   double M = objectives;
   double ratio = n / M;
   double[] res = new double[objectives];
   double[] constraints = new double[objectives];
   for (int j = 0; j < objectives; j++) {
     double sum = 0;
     for (int i = (int)(j * ratio); i < (j + 1) + ratio; i++) {
       sum += r[i];
     }
     sum /= (int)ratio;
     res[j] = sum;
   }
   for (int j = 0; j < M - 1; j++) {
     double d1 = res[objectives - 1] + 4 * res[j] - 1;
     constraints[j] = d1 < 0 ? -d1 : 0;
   }
   double min = Double.PositiveInfinity;
   for (int i = 0; i < res.Length - 1; i++) {
     for (int j = 0; j < i; j++) {
       double d2 = res[i] + res[j];
       if (min < d2) min = d2;
     }
   }
   double d = 2 * res[objectives - 1] + min - 1;
   constraints[constraints.Length - 1] = d < 0 ? -d : 0;
   return constraints;
 }
Ejemplo n.º 3
0
 /// <summary>
 /// Evaluates the test function for a specific <paramref name="point"/>.
 /// </summary>
 /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
 /// <returns>The result value of the Sum Squares function at the given point.</returns>
 public static double Apply(RealVector point) {
   double result = 0;
   for (int i = 0; i < point.Length; i++) {
     result += (i + 1) * point[i] * point[i];
   }
   return result;
 }
Ejemplo n.º 4
0
    public override double[] Evaluate(RealVector r, int objectives) {
      if (r.Length < objectives) {
        throw new ArgumentException("The dimensionality of the problem(ProblemSize) must be larger than or equal to the number of objectives");
      }
      double[] res = new double[objectives];

      //calculate g(Xm)
      double g = 0;
      for (int i = objectives; i < r.Length; i++) {
        g += Math.Pow(r[i], 0.1);
      }

      //phi definition
      Func<double, double> phi;
      phi = (double x) => { return Math.PI / (4 * (1 + g)) * (1 + 2 * g * x); };

      //calculating f0...fM-1
      for (int i = 0; i < objectives; i++) {
        double f = i == 0 ? 1 : (Math.Sin(phi(r[objectives - i - 1]) * Math.PI / 2)) * (1 + g);
        for (int j = 0; j < objectives - i - 1; j++) {
          f *= Math.Cos(phi(r[j]) * Math.PI / 2);
        }
        res[i] = f;
      }
      return res;
    }
Ejemplo n.º 5
0
 protected override double G(RealVector y) {
   double sum = 0.0;
   for (int i = 1; i < y.Length; i++) {
     sum += HG(y[i]);
   }
   return 1 + 9 * Math.Pow(sum / (y.Length - 1), 0.25);
 }
    /// <summary>
    /// Performs a breeder genetic algorithm manipulation on the given <paramref name="vector"/>.
    /// </summary>
    /// <param name="random">A random number generator.</param>
    /// <param name="vector">The real vector to manipulate.</param>
    /// <param name="bounds">The lower and upper bound (1st and 2nd column) of the positions in the vector. If there are less rows than dimensions, the rows are cycled.</param>
    /// <param name="searchIntervalFactor">The factor determining the size of the search interval.</param>
    public static void Apply(IRandom random, RealVector vector, DoubleMatrix bounds, DoubleValue searchIntervalFactor) {
      int length = vector.Length;
      double prob, value;
      do {
        value = Sigma(random);
      } while (value == 0);

      prob = 1.0 / (double)length;
      bool wasMutated = false;

      for (int i = 0; i < length; i++) {
        if (random.NextDouble() < prob) {
          double range = bounds[i % bounds.Rows, 1] - bounds[i % bounds.Rows, 0];
          if (random.NextDouble() < 0.5) {
            vector[i] = vector[i] + value * searchIntervalFactor.Value * range;
          } else {
            vector[i] = vector[i] - value * searchIntervalFactor.Value * range;
          }
          wasMutated = true;
        }
      }

      // make sure at least one gene was mutated
      if (!wasMutated) {
        int pos = random.Next(length);
        double range = bounds[pos % bounds.Rows, 1] - bounds[pos % bounds.Rows, 0];
        if (random.NextDouble() < 0.5) {
          vector[pos] = vector[pos] + value * searchIntervalFactor.Value * range;
        } else {
          vector[pos] = vector[pos] - value * searchIntervalFactor.Value * range;
        }
      }
    }
Ejemplo n.º 7
0
 /// <summary>
 /// Checks if all elements of the given <paramref name="vector"/> are inside the bounds and if not, elements are set to the respective values of the bounds.
 /// </summary>
 /// <param name="bounds">The lower and upper bound (1st and 2nd column) of the positions in the vector. If there are less rows than dimensions, the rows are cycled.</param>
 /// <param name="vector">The vector to check.</param>
 /// <returns>The corrected real vector.</returns>
 public static void Apply(RealVector vector, DoubleMatrix bounds) {
   for (int i = 0; i < vector.Length; i++) {
     double min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1];
     if (vector[i] < min) vector[i] = min;
     if (vector[i] > max) vector[i] = max;
   }
 }
 /// <summary>
 /// Mutates the endogenous strategy parameters.
 /// </summary>
 /// <param name="random">The random number generator to use.</param>
 /// <param name="vector">The strategy vector to manipulate.</param>
 /// <param name="generalLearningRate">The general learning rate dampens the mutation over all dimensions.</param>
 /// <param name="learningRate">The learning rate dampens the mutation in each dimension.</param>
 public static void Apply(IRandom random, RealVector vector, double generalLearningRate, double learningRate) {
   NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
   double generalMultiplier = Math.Exp(generalLearningRate * N.NextDouble());
   for (int i = 0; i < vector.Length; i++) {
     vector[i] *= generalMultiplier * Math.Exp(learningRate * N.NextDouble());
   }
 }
Ejemplo n.º 9
0
    public override double[] Evaluate(RealVector r, int objectives) {
      if (r.Length < 10 * objectives) throw new Exception("The dimensionality of the problem(ProblemSize) must be larger than ten times the number of objectives ");
      double n = r.Length;
      double M = objectives;
      double ratio = n / M;
      double[] res = new double[objectives];
      for (int j = 0; j < objectives; j++) {
        double sum = 0;
        for (int i = (int)(j * ratio); i < (j + 1) + ratio; i++) {
          sum += r[i];
        }
        sum /= (int)ratio;
        res[j] = sum;
      }
      for (int j = 0; j < M - 1; j++) {
        if (res[objectives - 1] + 4 * res[j] - 1 < 0) return IllegalValue(objectives, GetMaximization(objectives));
      }
      double min = Double.PositiveInfinity;
      for (int i = 0; i < res.Length - 1; i++) {
        for (int j = 0; j < i; j++) {
          double d = res[i] + res[j];
          if (min < d) min = d;
        }
      }

      if (2 * res[objectives - 1] + min - 1 < 0) return IllegalValue(objectives, GetMaximization(objectives));
      return res;
    }
Ejemplo n.º 10
0
    public override double[] Evaluate(RealVector r, int objectives) {
      if (r.Length < objectives) {
        throw new ArgumentException("The dimensionality of the problem(ProblemSize) must be larger than or equal to the number of objectives");
      }
      double[] res = new double[objectives];

      //calculate g(Xm)
      double sum = 0;
      int length = r.Length - objectives + 1;
      for (int i = r.Length - length; i < r.Length; i++) {
        double d = r[i] - 0.5;
        sum += d * d - Math.Cos(20 * Math.PI * d);
      }
      double g = 100 * (length + sum);

      //calculating f0...fM-1
      for (int i = 0; i < objectives; i++) {
        double f = i == 0 ? 1 : (Math.Sin(r[objectives - i - 1] * Math.PI / 2)) * (1 + g);
        for (int j = 0; j < objectives - i - 1; j++) {
          f *= Math.Cos(r[j] * Math.PI / 2);
        }
        res[i] = f;
      }
      return res;
    }
 /// <summary>
 /// Performs an adaptive normally distributed all position manipulation on the given 
 /// <paramref name="vector"/>.
 /// </summary>
 /// <exception cref="InvalidOperationException">Thrown when the strategy vector is not
 /// as long as the vector to get manipulated.</exception>
 /// <param name="sigma">The strategy vector determining the strength of the mutation.</param>
 /// <param name="random">A random number generator.</param>
 /// <param name="vector">The real vector to manipulate.</param>
 /// <returns>The manipulated real vector.</returns>
 public static void Apply(IRandom random, RealVector vector, RealVector sigma) {
   if (sigma == null || sigma.Length == 0) throw new ArgumentException("ERROR: Vector containing the standard deviations is not defined.", "sigma");
   NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
   for (int i = 0; i < vector.Length; i++) {
     vector[i] = vector[i] + (N.NextDouble() * sigma[i % sigma.Length]);
   }
 }
Ejemplo n.º 12
0
    public override double[] Evaluate(RealVector r, int objectives) {
      if (objectives != 2) throw new ArgumentException("The CIGTAB problem must always have 2 objectives");
      double x = r[0];
      double a = 1000;
      double sum = x * x;
      for (int i = 1; i < r.Length - 1; i++) {
        sum += a * r[i] * r[i];
      }
      sum += a * a * r[r.Length - 1] * r[r.Length - 1];

      //objective1
      double f0 = 1 / (a * a * r.Length) * sum;

      x = x - 2;
      sum = x * x;
      for (int i = 1; i < r.Length - 1; i++) {
        sum += a * (r[i] - 2) * (r[i] - 2);
      }

      sum += a * a * (r[r.Length - 1] - 2) * (r[r.Length - 1] - 2);
      //objective0
      double f1 = 1 / (a * a * r.Length) * sum;

      return new double[] { f0, f1 };
    }
 protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
   RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
   var eval = EvaluatorParameter.ActualValue as MultinormalEvaluator;
   if (eval != null)
     return eval.Evaluate(wrapper);
   throw new InvalidOperationException("evaluator is not a multinormal evaluator");
 }
Ejemplo n.º 14
0
    public override double[] Evaluate(RealVector r, int objectives) {
      if (r.Length < objectives) {
        throw new ArgumentException("The dimensionality of the problem(ProblemSize) must be larger than or equal to the number of objectives");
      }
      double[] res = new double[objectives];

      //calculate g(Xm)
      double g = 0, length = length = r.Length - objectives + 1;
      for (int i = objectives; i < r.Length; i++) {
        g += r[i];
      }
      g = 1.0 + 9.0 / length * g;
      if (length == 0) { g = 1; }

      //calculating f0...fM-2
      for (int i = 0; i < objectives - 1; i++) {
        res[i] = r[i];
      }
      //calculate fM-1
      double h = objectives;
      for (int i = 0; i < objectives - 1; i++) {
        h -= res[i] / (1 + g) * (1 + Math.Sin(3 * Math.PI * res[i]));
      }
      res[objectives - 1] = (1 + g) * h;

      return res;
    }
Ejemplo n.º 15
0
 protected override double G(RealVector y) {
   double sum = 0.0;
   for (int i = 1; i < y.Length; i++) {
     sum += y[i] * y[i] - 10 * Math.Cos(4 * Math.PI * y[i]);
   }
   return 1 + 10 * (y.Length - 1) + sum;
 }
Ejemplo n.º 16
0
 public override double[] Evaluate(RealVector r) {
   double g = 0;
   for (int i = 1; i < r.Length; i++) g += r[i];
   g = 1.0 + 9.0 * g / (r.Length - 1);
   double f0 = r[0];
   double f1 = g * (1.0 - Math.Sqrt(r[0] / g));
   return new double[] { f0, f1 };
 }
Ejemplo n.º 17
0
 protected override IEnumerable<double[]> GetOptimalParetoFront(int objectives) {
   List<double[]> res = new List<double[]>();
   for (int i = 0; i <= 500; i++) {
     RealVector r = new RealVector(objectives);
     r[0] = 1 / 500.0 * i;
     res.Add(this.Evaluate(r, objectives));
   }
   return res;
 }
Ejemplo n.º 18
0
 public override double[] Evaluate(RealVector r) {
   double g = 0;
   for (int i = 1; i < r.Length; i++) g += r[i];
   g = 1.0 + 9.0 * Math.Pow(g / (r.Length - 1), 0.25);
   double f1 = 1 - Math.Exp(-4 * r[0]) * Math.Pow(Math.Sin(6 * Math.PI * r[0]), 6);
   double d = f1 / g;
   double f2 = g * (1.0 - d * d);
   return new double[] { f1, f2 };
 }
 /// <summary>
 /// Performs the arithmetic crossover on all positions by calculating x = alpha * p1 + (1 - alpha) * p2.
 /// </summary>
 /// <exception cref="ArgumentException">Thrown when the parent vectors are of different length or alpha is outside the range [0;1].</exception>
 /// <param name="random">The random number generator.</param>
 /// <param name="parent1">The first parent vector.</param>
 /// <param name="parent2">The second parent vector.</param>
 /// <param name="alpha">The alpha parameter (<see cref="AlphaParameter"/>).</param>
 /// <returns>The vector resulting from the crossover.</returns>
 public static RealVector Apply(IRandom random, RealVector parent1, RealVector parent2, DoubleValue alpha) {
   int length = parent1.Length;
   if (length != parent2.Length) throw new ArgumentException("UniformAllPositionsArithmeticCrossover: The parent vectors are of different length.", "parent1");
   if (alpha.Value < 0 || alpha.Value > 1) throw new ArgumentException("UniformAllPositionsArithmeticCrossover: Parameter alpha must be in the range [0;1]", "alpha");
   RealVector result = new RealVector(length);
   for (int i = 0; i < length; i++) {
     result[i] = alpha.Value * parent1[i] + (1 - alpha.Value) * parent2[i];
   }
   return result;
 }
Ejemplo n.º 20
0
    /// <summary>
    /// Evaluates the test function for a specific <paramref name="point"/>.
    /// </summary>
    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    /// <returns>The result value of the Zakharov function at the given point.</returns>
    public static double Apply(RealVector point) {
      int length = point.Length;
      double s1 = 0;
      double s2 = 0;

      for (int i = 0; i < length; i++) {
        s1 += point[i] * point[i];
        s2 += 0.5 * i * point[i];
      }
      return s1 + (s2 * s2) + (s2 * s2 * s2 * s2);
    }
Ejemplo n.º 21
0
 public override double[] Evaluate(RealVector r) {
   double g = 0;
   for (int i = 1; i < r.Length; i++) {
     double v = r[i];
     g += v * v - 10 * Math.Cos(4 * Math.PI * v);
   }
   g = 1.0 + 10.0 * (r.Length - 1) + g;
   double d = r[0] / g;
   double f0 = r[0];
   double f1 = 1 - Math.Sqrt(d);
   return new double[] { f0, f1 };
 }
 public static AdditiveMove[] Apply(IRandom random, RealVector vector, double contiguity, int sampleSize, double maxManipulation, DoubleMatrix bounds) {
   AdditiveMove[] moves = new AdditiveMove[sampleSize];
   for (int i = 0; i < sampleSize; i++) {
     int index = random.Next(vector.Length);
     double strength = 0, min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1];
     do {
       strength = PolynomialOnePositionManipulator.Apply(random, contiguity) * maxManipulation;
     } while (vector[index] + strength < min || vector[index] + strength > max);
     moves[i] = new AdditiveMove(index, strength);
   }
   return moves;
 }
Ejemplo n.º 23
0
    /// <summary>
    /// Performs a random convex crossover on the two given parents.
    /// </summary>
    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
    /// <param name="random">The random number generator.</param>
    /// <param name="parent1">The first parent vector for the crossover.</param>
    /// <param name="parent2">The second parent vector for the crossover.</param>
    /// <returns>The newly created real vector, resulting from the random convex crossover.</returns>
    public static RealVector Apply(IRandom random, RealVector parent1, RealVector parent2) {
      if (parent1.Length != parent2.Length)
        throw new ArgumentException("ERROR in RandomConvexCrossover: the two parents are not of the same length");

      int length = parent1.Length;
      double[] result = new double[length];
      double factor = random.NextDouble();

      for (int i = 0; i < length; i++)
        result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
      return new RealVector(result);
    }
Ejemplo n.º 24
0
 private IEnumerable<RealVector> GetCenters(int nDim) {
   RealVector r0 = new RealVector(nDim);
   for (int i = 0; i < r0.Length; i++)
     r0[i] = 5;
   yield return r0;
   for (int i = 1; i < 1 << nDim; i++) {
     RealVector r = new RealVector(nDim);
     for (int j = 0; j < nDim; j++) {
       r[j] = (i >> j) % 2 == 0 ? Random.NextDouble() + 4.5 : Random.NextDouble() + 14.5;
     }
     yield return r;
   }
 }
Ejemplo n.º 25
0
    /// <summary>
    /// Perfomrs a heuristic crossover on the two given parents.
    /// </summary>
    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
    /// <param name="random">The random number generator.</param>
    /// <param name="betterParent">The first parent for the crossover operation.</param>
    /// <param name="worseParent">The second parent for the crossover operation.</param>
    /// <returns>The newly created real vector, resulting from the heuristic crossover.</returns>
    public static RealVector Apply(IRandom random, RealVector betterParent, RealVector worseParent) {
      if (betterParent.Length != worseParent.Length)
        throw new ArgumentException("HeuristicCrossover: the two parents are not of the same length");

      int length = betterParent.Length;
      double[] result = new double[length];
      double factor = random.NextDouble();

      for (int i = 0; i < length; i++) {
        result[i] = betterParent[i] + factor * (betterParent[i] - worseParent[i]);
      }
      return new RealVector(result);
    }
 public static AdditiveMove[] Apply(IRandom random, RealVector vector, double sigma, int sampleSize, DoubleMatrix bounds) {
   AdditiveMove[] moves = new AdditiveMove[sampleSize];
   NormalDistributedRandom N = new NormalDistributedRandom(random, 0, sigma);
   for (int i = 0; i < sampleSize; i++) {
     int index = random.Next(vector.Length);
     double strength = 0, min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1];
     do {
       strength = N.NextDouble();
     } while (vector[index] + strength < min || vector[index] + strength > max);
     moves[i] = new AdditiveMove(index, strength);
   }
   return moves;
 }
Ejemplo n.º 27
0
    public override double[] Evaluate(RealVector r, int objectives) {
      if (objectives != 2) throw new ArgumentException("The Schaffer N1 problem must always have 2 objectives");
      if (r.Length != 1) return null;
      double x = r[0];

      //objective1
      double f0 = x * x;

      //objective0
      double f1 = x - 2;
      f1 *= f1;

      return new double[] { f0, f1 };
    }
Ejemplo n.º 28
0
    /// <summary>
    /// Performs a discrete crossover operation on multiple parents.
    /// </summary>
    /// <exception cref="ArgumentException">Thrown when the vectors of the parents are of different length.</exception>
    /// <param name="random">A random number generator.</param>
    /// <param name="parents">An array containing the parents that should be crossed.</param>
    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
    public static RealVector Apply(IRandom random, ItemArray<RealVector> parents) {
      int length = parents[0].Length;

      for (int i = 0; i < parents.Length; i++) {
        if (parents[i].Length != length)
          throw new ArgumentException("DiscreteCrossover: The parents' vectors are of different length.", "parents");
      }

      RealVector result = new RealVector(length);
      for (int i = 0; i < length; i++) {
        result[i] = parents[random.Next(parents.Length)][i];
      }

      return result;
    }
    /// <summary>
    /// Performs the polynomial mutation on a single position in the real vector.
    /// </summary>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="vector">The vector that should be manipulated.</param>
    /// <param name="contiguity">A parameter describing the shape of the probability density function which influences the strength of the manipulation.</param>
    /// <param name="maxManipulation">The maximum strength of the manipulation.</param>
    public static void Apply(IRandom random, RealVector vector, DoubleValue contiguity, DoubleValue maxManipulation) {
      if (contiguity.Value < 0) throw new ArgumentException("PolynomialAllPositionManipulator: Contiguity value is smaller than 0", "contiguity");
      double u, delta = 0;

      for (int index = 0; index < vector.Length; index++) {
        u = random.NextDouble();
        if (u < 0.5) {
          delta = Math.Pow(2 * u, 1.0 / (contiguity.Value + 1)) - 1.0;
        } else if (u >= 0.5) {
          delta = 1.0 - Math.Pow(2.0 - 2.0 * u, 1.0 / (contiguity.Value + 1));
        }

        vector[index] += delta * maxManipulation.Value;
      }
    }
Ejemplo n.º 30
0
    public override double[] Evaluate(RealVector r, int objectives) {
      if (objectives != 2) throw new ArgumentException("The Kursawe problem must always have 2 objectives");
      //objective 1
      double f0 = 0.0;
      for (int i = 0; i < r.Length - 1; i++) {
        f0 += -10 * Math.Exp(-0.2 * Math.Sqrt(r[i] * r[i] + r[i + 1] * r[i + 1]));
      }
      //objective2
      double f1 = 0.0;
      for (int i = 0; i < r.Length; i++) {
        f1 += Math.Pow(Math.Abs(r[i]), 0.8) + 5 * Math.Sin(Math.Pow(r[i], 3));
      }

      return new double[] { f0, f1 };
    }
 protected abstract AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector, DoubleMatrix bounds);