Add dependency injections

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/GeneticSolver.java

@@ -19,6 +19,7 @@ import org.opt4j.core.start.Opt4JTask;
 import org.opt4j.optimizers.ea.EvolutionaryAlgorithmModule;
 import org.opt4j.optimizers.ea.Nsga2Module;
 import org.opt4j.optimizers.ea.Spea2Module;
+import org.opt4j.optimizers.ea.EvolutionaryAlgorithmModule.CrossoverRateType;
 
 import java.util.concurrent.TimeUnit;
 
@@ -41,6 +42,22 @@ public class GeneticSolver implements BenchmarkableSolver {
   private SelectorType selectorType;
   private boolean timedOut;
 
+  //
+  private double treeCrossoverOperatorMin;
+  private double treeCrossoverOperatorMax;
+  private double treeCrossoverOperatorProbability;
+
+  private double treeMutateOperatorMin;
+  private double treeMutateOperatorMax;
+  private double treeMutateOperatorP;
+  private double treeMutateOperatorP1;
+  private double treeMutateOperatorP2;
+  private double treeMutateOperatorP3;
+
+  private double opt4jEvaluatorK1;
+  private double opt4jEvaluatorK2;
+  //
+
   public GeneticSolver() {
     this(SelectorType.NSGA2, 100, 100);
   }
@@ -68,15 +85,33 @@ public class GeneticSolver implements BenchmarkableSolver {
     Opt4jModule.setModel(model);
 
     EvolutionaryAlgorithmModule ea = new EvolutionaryAlgorithmModule();
-    ea.setGenerations(this.generations);
-
-    // set population size
-    ea.setAlpha(this.populationSize);
+    ea.setGenerations(this.generations); //The number of generations.
+    ea.setAlpha(this.populationSize); //The size of the population.4
+    //
+    ea.setLambda(lambda); //The number of offspring per generation. //Dep inj no
+    ea.setCrossoverRate(crossoverRate); //Performs a crossover operation with this given rate. //Dep inj no
+    ea.setCrossoverRateType(CrossoverRateType.CONSTANT); // no more variants //Dep inj no
+    ea.setMu(mu); //The number of parents per generation. //Dep inj no
+    //
 
     Opt4jModule mquatModule = new Opt4jModule();
 
     mquatModule.setMaxSolvingTime(this.maxSolvingTime);
 
+    //
+    mquatModule.setTreeCrossoverOperatorMin(this.treeCrossoverOperatorMin);
+    mquatModule.setTreeCrossoverOperatorMax(this.treeCrossoverOperatorMax);
+    mquatModule.setTreeCrossoverOperatorProbability(this.treeCrossoverOperatorProbability);
+    mquatModule.setTreeMutateOperatorMin(this.treeMutateOperatorMin);
+    mquatModule.setTreeMutateOperatorMax(this.treeMutateOperatorMax);
+    mquatModule.setTreeMutateOperatorP(this.treeMutateOperatorP);
+    mquatModule.setTreeMutateOperatorP1(this.treeMutateOperatorP1);
+    mquatModule.setTreeMutateOperatorP2(this.treeMutateOperatorP2);
+    mquatModule.setTreeMutateOperatorP3(this.treeMutateOperatorP3);
+    mquatModule.setOpt4jEvaluatorK1(this.opt4jEvaluatorK1);
+    mquatModule.setOpt4jEvaluatorK2(this.opt4jEvaluatorK2);
+    //
+
     TreeCrossoverOperatorModule crossover = new TreeCrossoverOperatorModule();
     TreeMutateOperatorModule mutate = new TreeMutateOperatorModule();
     TreeCopyOperatorModule copy = new TreeCopyOperatorModule();
@@ -89,11 +124,13 @@ public class GeneticSolver implements BenchmarkableSolver {
     switch (this.selectorType) {
       case NSGA2:
         Nsga2Module nsga2 = new Nsga2Module();
+        nsga2.setTournament(tournament); //Dep inj no
         task.init(optimizerModule, ea, nsga2, mquatModule, crossover, mutate, copy);
 //        task.init(optimizerModule, ea, nsga2, mquatModule, crossover, mutate, copy, viewer);
         break;
       case SPEA2:
         Spea2Module spea2 = new Spea2Module();
+        spea2.setTournament(tournament); //Dep inj no
         task.init(optimizerModule, ea, spea2, mquatModule, crossover, mutate, copy);
 //        task.init(optimizerModule, ea, spea2, mquatModule, crossover, mutate, copy, viewer);
     }
@@ -150,6 +187,8 @@ public class GeneticSolver implements BenchmarkableSolver {
     return this;
   }
 
+  
+
   @Override
   public boolean hadTimeout() {
     return this.timedOut;

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/Opt4jEvaluator.java

 package de.tudresden.inf.st.mquat.solving.genetic.opt4j;
 
 import de.tudresden.inf.st.mquat.jastadd.model.Solution;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.Opt4jEvaluatorK1;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.Opt4jEvaluatorK2;
+
 import org.opt4j.core.Objective.Sign;
 import org.opt4j.core.Objectives;
 import org.opt4j.core.problem.Evaluator;
 
 public class Opt4jEvaluator implements Evaluator<Solution> {
 
+  //
+  private double opt4jEvaluatorK1;
+  private double opt4jEvaluatorK2;
+  //
+
+  //
+  @Inject
+  public Opt4jEvaluator(@Opt4jEvaluatorK1 double opt4jEvaluatorK1, @Opt4jEvaluatorK2 double opt4jEvaluatorK2) {
+    this.opt4jEvaluatorK1 = opt4jEvaluatorK1;
+    this.opt4jEvaluatorK2 = opt4jEvaluatorK2;
+  }
+  //
+
   @Override
   public Objectives evaluate(Solution phenotype) {
     Objectives objectives = new Objectives();
@@ -19,8 +35,8 @@ public class Opt4jEvaluator implements Evaluator<Solution> {
 
     double objective = phenotype.computeObjective();
 
-    objective += validity * 0.5 * objective;
-    objective += softwareValidity * 0.5 * objective;
+    objective += validity * this.opt4jEvaluatorK1 * objective; //Dep inj Opt4jEvaluatorK1
+    objective += softwareValidity * this.opt4jEvaluatorK2 * objective; //Dep inj Opt4jEvaluatorK2
 
     objectives.add("Energy", Sign.MIN, objective);
 

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/Opt4jModule.java

@@ -2,6 +2,19 @@ package de.tudresden.inf.st.mquat.solving.genetic.opt4j;
 
 import de.tudresden.inf.st.mquat.jastadd.model.Root;
 import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.optimizer.MaxSolvingTime;
+//
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeCrossoverOperatorMin;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeCrossoverOperatorMax;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeCrossoverOperatorProbability;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorMin;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorMax;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorP;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorP1;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorP2;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorP3;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.Opt4jEvaluatorK1;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.Opt4jEvaluatorK2;
+//
 import org.opt4j.core.problem.ProblemModule;
 
 public class Opt4jModule extends ProblemModule {
@@ -10,6 +23,33 @@ public class Opt4jModule extends ProblemModule {
   public Long maxSolvingTime = Long.MAX_VALUE;
   private static Root model;
 
+  //
+  @TreeCrossoverOperatorMin
+  public double treeCrossoverOperatorMin = 0.0d;
+  @TreeCrossoverOperatorMax
+  public double treeCrossoverOperatorMax = 1.0d;
+  @TreeCrossoverOperatorProbability
+  public double treeCrossoverOperatorProbability = 0.5;
+
+  @TreeMutateOperatorMin
+  public double treeMutateOperatorMin = 0.0d;
+  @TreeMutateOperatorMax
+  public double treeMutateOperatorMax = 1.0d;
+  @TreeMutateOperatorP
+  public double treeMutateOperatorP = 0.9;
+  @TreeMutateOperatorP1
+  public double treeMutateOperatorP1 = 3.0;
+  @TreeMutateOperatorP2
+  public double treeMutateOperatorP2 = 0.7;
+  @TreeMutateOperatorP3
+  public double treeMutateOperatorP3 = 0.4;
+
+  @Opt4jEvaluatorK1
+  public double opt4jEvaluatorK1 = 0.5;
+  @Opt4jEvaluatorK2
+  public double opt4jEvaluatorK2 = 0.5;
+  //
+
   public static Root getModel() {
     return model;
   }
@@ -22,10 +62,71 @@ public class Opt4jModule extends ProblemModule {
     this.maxSolvingTime = maxSolvingTime;
   }
 
+  //
+  public void setTreeCrossoverOperatorMin(double treeCrossoverOperatorMin) {
+    this.treeCrossoverOperatorMin = treeCrossoverOperatorMin;
+  }
+
+  public void setTreeCrossoverOperatorMax(double treeCrossoverOperatorMax) {
+    this.treeCrossoverOperatorMax = treeCrossoverOperatorMax;
+  }
+
+  public void setTreeCrossoverOperatorProbability(double treeCrossoverOperatorProbability) {
+    this.treeCrossoverOperatorProbability = treeCrossoverOperatorProbability;
+  }
+  
+  public void setTreeMutateOperatorMin(double treeMutateOperatorMin) {
+    this.treeMutateOperatorMin = treeMutateOperatorMin;
+  }
+  
+  public void setTreeMutateOperatorMax(double treeMutateOperatorMax) {
+    this.treeMutateOperatorMax = treeMutateOperatorMax;
+  }
+  
+  public void setTreeMutateOperatorP(double treeMutateOperatorP) {
+    this.treeMutateOperatorP = treeMutateOperatorP;
+  }
+  
+  public void setTreeMutateOperatorP1(double treeMutateOperatorP1) {
+    this.treeMutateOperatorP1 = treeMutateOperatorP1;
+  }
+  
+  public void setTreeMutateOperatorP2(double treeMutateOperatorP2) {
+    this.treeMutateOperatorP2 = treeMutateOperatorP2;
+  }
+  
+  public void setTreeMutateOperatorP3(double treeMutateOperatorP3) {
+    this.treeMutateOperatorP3 = treeMutateOperatorP3;
+  }
+  
+  public void setOpt4jEvaluatorK1(double opt4jEvaluatorK1) {
+    this.opt4jEvaluatorK1 = opt4jEvaluatorK1;
+  }
+  
+  public void setOpt4jEvaluatorK2(double opt4jEvaluatorK2) {
+    this.opt4jEvaluatorK2 = opt4jEvaluatorK2;
+  }
+  
+
+  //
+
   @Override
   protected void configure() {
     bindProblem(Opt4jCreator.class, Opt4jDecoder.class, Opt4jEvaluator.class);
     bindConstant(MaxSolvingTime.class).to(maxSolvingTime);
+    //
+    bindConstant(TreeCrossoverOperatorMin.class).to(treeCrossoverOperatorMin);
+    bindConstant(TreeCrossoverOperatorMax.class).to(treeCrossoverOperatorMax);
+    bindConstant(TreeCrossoverOperatorProbability.class).to(treeCrossoverOperatorProbability);
+    bindConstant(TreeMutateOperatorMin.class).to(treeMutateOperatorMin);
+    bindConstant(TreeMutateOperatorMax.class).to(treeMutateOperatorMax);
+    bindConstant(TreeMutateOperatorP.class).to(treeMutateOperatorP);
+    bindConstant(TreeMutateOperatorP1.class).to(treeMutateOperatorP1);
+    bindConstant(TreeMutateOperatorP2.class).to(treeMutateOperatorP2);
+    bindConstant(TreeMutateOperatorP3.class).to(treeMutateOperatorP3);
+    bindConstant(Opt4jEvaluatorK1.class).to(opt4jEvaluatorK1);
+    bindConstant(Opt4jEvaluatorK2.class).to(opt4jEvaluatorK2);
+    //
   }
 
   @Override

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/crossover/TreeCrossoverOperator.java

@@ -7,6 +7,10 @@ import de.tudresden.inf.st.mquat.jastadd.model.Request;
 import de.tudresden.inf.st.mquat.jastadd.model.Resource;
 import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.genotypes.TreeGenotype;
 import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.genotypes.TreeGenotypeNode;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeCrossoverOperatorMax;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeCrossoverOperatorMin;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeCrossoverOperatorProbability;
+
 import org.opt4j.core.common.random.Rand;
 import org.opt4j.operators.Apply;
 import org.opt4j.operators.crossover.Crossover;
@@ -18,13 +22,18 @@ import java.util.Random;
 public class TreeCrossoverOperator implements Crossover<TreeGenotype<Request, Instance, Resource, Implementation>> {
 
   private final Random random;
-  private static final double Min = 0.0d;
-  private static final double Max = 1.0d;
-  private static final double probability = 0.5;
+  private final double Min = 0.0d; //Dep inj TreeCrossoverOperatorMin
+  private final double Max = 1.0d; //Dep inj TreeCrossoverOperatorMax
+  private final double probability = 0.5; //Dep inj TreeCrossoverOperatorProbability
 
   @Inject
-  public TreeCrossoverOperator(Rand random) {
+  public TreeCrossoverOperator(Rand random, @TreeCrossoverOperatorMin double treeCrossoverOperatorMin, @TreeCrossoverOperatorMax double treeCrossoverOperatorMax, @TreeCrossoverOperatorProbability double treeCrossoverOperatorProbability) {
     this.random = random;
+    //
+    this.Min = treeCrossoverOperatorMin;
+    this.Max = treeCrossoverOperatorMax;
+    this.probability = treeCrossoverOperatorProbability;
+    //
   }
 
   @Override
@@ -79,7 +88,7 @@ public class TreeCrossoverOperator implements Crossover<TreeGenotype<Request, In
     } else {
       // TODO figure out what to swap
 
-      double randomValue = Min + (Max - Min) * this.random.nextDouble();
+      double randomValue = this.Min + (this.Max - this.Min) * this.random.nextDouble();
 
       boolean swapImpl = this.random.nextBoolean();
       boolean swapResource = this.random.nextBoolean();

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/mutate/TreeMutateOperator.java

@@ -5,6 +5,13 @@ import de.tudresden.inf.st.mquat.jastadd.model.*;
 import de.tudresden.inf.st.mquat.solving.genetic.opt4j.Opt4jCreator;
 import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.genotypes.TreeGenotype;
 import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.genotypes.TreeGenotypeNode;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorMax;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorMin;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorP;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorP1;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorP2;
+import de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params.TreeMutateOperatorP3;
+
 import org.opt4j.core.common.random.Rand;
 import org.opt4j.operators.Apply;
 import org.opt4j.operators.mutate.Mutate;
@@ -16,25 +23,40 @@ import java.util.Random;
 public class TreeMutateOperator implements Mutate<TreeGenotype<Request, Instance, Resource, Implementation>> {
 
   private final Random random;
-  private static final double Min = 0.0d;
-  private static final double Max = 1.0d;
+  private final double Min = 0.0d; //Dep inj TreeMutateOperatorMin
+  private final double Max = 1.0d; //Dep inj TreeMutateOperatorMax
+
+  //
+  private double treeMutateOperatorP;
+  private double treeMutateOperatorP1;
+  private double treeMutateOperatorP2;
+  private double treeMutateOperatorP3;
+  //
 
   @Inject
-  public TreeMutateOperator(Rand random) {
+  public TreeMutateOperator(Rand random, @TreeMutateOperatorMax double treeMutateOperatorMax, @TreeMutateOperatorMin double treeMutateOperatorMin, @TreeMutateOperatorP double treeMutateOperatorP, @TreeMutateOperatorP1 double treeMutateOperatorP1, @TreeMutateOperatorP2 double treeMutateOperatorP2, @TreeMutateOperatorP3 double treeMutateOperatorP3) {
     this.random = random;
+    //
+    this.Min = treeMutateOperatorMin;
+    this.Max = treeMutateOperatorMax;
+    this.treeMutateOperatorP = treeMutateOperatorP;
+    this.treeMutateOperatorP1 = treeMutateOperatorP1;
+    this.treeMutateOperatorP2 = treeMutateOperatorP2;
+    this.treeMutateOperatorP3 = treeMutateOperatorP3;
+    //
   }
 
   @Override
-  public void mutate(TreeGenotype<Request, Instance, Resource, Implementation> genotype, double p) {
+  public void mutate(TreeGenotype<Request, Instance, Resource, Implementation> genotype, @TreeMutateOperatorP double p) {
 
-    p = 0.9;
+    //p = 0.9; //Dep inj TreeMutateOperatorP
 
     for (Request e : genotype.getRequestMap()
         .keySet()) {
 
       TreeGenotypeNode<Request, Instance, Resource, Implementation> node = genotype.getRequestMap().get(e);
 
-      double randomValue = Min + (Max - Min) * this.random.nextDouble();
+      double randomValue = this.Min + (this.Max - this.Min) * this.random.nextDouble();
 
       if (randomValue < p) {
         genotype.getRequestMap().put(e, mutateNode(e, node, p));
@@ -48,11 +70,11 @@ public class TreeMutateOperator implements Mutate<TreeGenotype<Request, Instance
 
 
 
-    double randomValue = Min + (Max - Min) * random.nextDouble();
+    double randomValue = this.Min + (this.Max - this.Min) * random.nextDouble();
 
-    if (randomValue < p/3.0) {
+    if (randomValue < p/this.treeMutateOperatorP1) { //Dep inj TreeMutateOperatorP1
       List<Resource> unassignedResources = node.getContainingGenotype().getResources();
-      if (random.nextDouble() > 0.7) {
+      if (random.nextDouble() > this.treeMutateOperatorP2) { //Dep inj TreeMutateOperatorP2
         // mutate the resources
         unassignedResources.add(node.getResource());
         // get a random unassigned resource
@@ -60,7 +82,7 @@ public class TreeMutateOperator implements Mutate<TreeGenotype<Request, Instance
         node.setResource(unassignedResources.get(resourceIndex));
         unassignedResources.remove(resourceIndex);
       }
-      if (random.nextDouble() > 0.4) {
+      if (random.nextDouble() > this.treeMutateOperatorP3) { //Dep inj TreeMutateOperatorP3
         // mutate the implementation
         Component comp = node.getImpl().containingComponent();
         Implementation newImp = comp.getImplementation(random.nextInt(comp.getNumImplementation()));

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/Opt4jEvaluatorK1.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface Opt4jEvaluatorK1 {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/Opt4jEvaluatorK2.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface Opt4jEvaluatorK2 {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/TreeCrossoverOperatorMax.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface TreeCrossoverOperatorMax {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/TreeCrossoverOperatorMin.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface TreeCrossoverOperatorMin {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/TreeCrossoverOperatorProbability.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface TreeCrossoverOperatorProbability {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/TreeMutateOperatorMax.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface TreeMutateOperatorMax {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/TreeMutateOperatorMin.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface TreeMutateOperatorMin {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/TreeMutateOperatorP.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface TreeMutateOperatorP {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/TreeMutateOperatorP1.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface TreeMutateOperatorP1 {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/TreeMutateOperatorP2.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface TreeMutateOperatorP2 {
+
+}
\ No newline at end of file

jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/params/TreeMutateOperatorP3.java

+package de.tudresden.inf.st.mquat.solving.genetic.opt4j.custom.params;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@BindingAnnotation
+public @interface TreeMutateOperatorP3 {
+
+}
\ No newline at end of file