Changes from MK rev. 255, update to ParticleFilter, and tool tips dont break at points.

src/eva2/gui/PropertySheetPanel.java

@@ -36,7 +36,6 @@ import java.beans.PropertyVetoException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-
 import javax.swing.BorderFactory;
 import javax.swing.JButton;
 import javax.swing.JComponent;
@@ -45,6 +44,7 @@ import javax.swing.JPanel;
 import javax.swing.JTextArea;
 import javax.swing.SwingConstants;
 
+import eva2.gui.GenericObjectEditor.GOEPanel;
 import eva2.tools.EVAHELP;
 import eva2.tools.StringTools;
 /*==========================================================================*
@@ -91,6 +91,9 @@ public class PropertySheetPanel extends JPanel implements PropertyChangeListener
     private PropertyChangeSupport   m_support = new PropertyChangeSupport(this);
     /** set true to use the GOE by default if no other editor is registered **/
 
+    // If true, tool tips are used up to the first point only. 
+    boolean stripToolTipToFirstPoint=false;
+    
     /** Creates the property sheet panel.
      */
     public PropertySheetPanel() {
@@ -105,6 +108,9 @@ public class PropertySheetPanel extends JPanel implements PropertyChangeListener
      */
     public void propertyChange(PropertyChangeEvent evt) {
         if (TRACE) System.out.println("PropertySheetPanel.propertyChange() "+m_Target.getClass()+": calling wasModified");
+        // GOEPanel gp=(GOEPanel)this.getParent();
+        // gp.validateTarget(this); // Once trying to find an irreproducible bug
+        
         wasModified(evt); // Let our panel update before guys downstream
         m_support.removePropertyChangeListener(this);
         m_support.firePropertyChange("", null, m_Target);
@@ -841,9 +847,11 @@ public class PropertySheetPanel extends JPanel implements PropertyChangeListener
 	                try {
                         Object  args[]  = { };
 		                String  tempTip = (String)(meth.invoke(target, args));
+		                result = tempTip;
+		                if (stripToolTipToFirstPoint) {
 		                	int     ci      = tempTip.indexOf('.');
-		                if (ci < 0) result = tempTip;
+		                	if (ci > 0) result = tempTip.substring(0, ci);
-		                else        result = tempTip.substring(0, ci);
+		                }
 	                } catch (Exception ex) {
                     }
 	                break;

src/eva2/server/go/operators/distancemetric/EuclideanMetric.java

@@ -0,0 +1,51 @@
+package eva2.server.go.operators.distancemetric;
+
+import eva2.server.go.individuals.AbstractEAIndividual;
+
+/**
+ * The Euclidean metric just measures the Euclidean distance based on the default double representation
+ * as given by AbstractEAIndividual.getDoublePosition(AbstractEAIndividual).
+ * 
+ * @see AbstractEAIndividual.getDoublePosition(AbstractEAIndividual)
+ * @author mkron
+ *
+ */
+public class EuclideanMetric implements InterfaceDistanceMetric {
+
+	public Object clone() {
+		return (Object) new EuclideanMetric(this);
+	}
+
+	public EuclideanMetric(EuclideanMetric a) {
+	}
+
+	public EuclideanMetric() {
+	}
+
+	public double distance(AbstractEAIndividual indy1, AbstractEAIndividual indy2) {
+		double[]    dIndy1, dIndy2;
+		double      result = 0;
+
+		dIndy1 = AbstractEAIndividual.getDoublePosition(indy1);
+		dIndy2 = AbstractEAIndividual.getDoublePosition(indy2);
+
+		for (int i = 0; (i < dIndy1.length) && (i < dIndy2.length); i++) {
+			result += Math.pow((dIndy1[i] - dIndy2[i]), 2);
+		}
+		return Math.sqrt(result);
+	}
+
+	/** This method returns a global info string
+	 * @return description
+	 */
+	public String globalInfo() {
+		return "The euclidean metric calculates euclidian distances for individuals which have a real valued interpretation.";
+	}
+	/** This method will return a naming String
+	 * @return The name of the algorithm
+	 */
+	public String getName() {
+		return "Euclidean Metric";
+	}
+}
+

src/eva2/server/go/operators/mutation/MutateESCorrVector.java

@@ -0,0 +1,259 @@
+package eva2.server.go.operators.mutation;
+
+import java.util.ArrayList;
+
+import eva2.gui.BeanInspector;
+import eva2.server.go.individuals.AbstractEAIndividual;
+import eva2.server.go.individuals.InterfaceESIndividual;
+import eva2.server.go.populations.Population;
+import eva2.server.go.problems.InterfaceOptimizationProblem;
+import wsi.ra.math.RNG;
+import eva2.tools.Mathematics;
+import eva2.tools.SelectedTag;
+
+
+/**
+ * The correlated vector mutations stores a "velocity" vector for each individual,
+ * updates the velocity by rotation and scaling, and then mutates the individual
+ * by adding the velocity. This was used for a particle filter localization problem
+ * and is less useful in general.
+ * 
+ * Rotation vectors are normal distributed with mean zero, scaling factors are
+ * log-normally distributed around mean 1. This means that the averaged expected change
+ * of the mutation vector is zero. The smaller the deviations, the higher the correlations
+ * between successive mutation steps.
+ */
+public class MutateESCorrVector implements InterfaceMutation, java.io.Serializable {
+    protected double      m_scalingDev    = 0.05;
+    protected double      m_initialVelocity     = 0.02;
+    protected double      m_LowerLimitStepSize  = 0.0000001;
+    protected double      m_UpperLimitStepSize  = 0.5;
+	protected double 		m_rotationDev = 15.;
+	protected boolean		m_checkConstraints = true;
+    public static final String vectorKey = "MutateESCorrVectorVector";
+    public static final boolean TRACE = false;
+
+    public MutateESCorrVector() {
+    }
+
+    public MutateESCorrVector(double scalingDev) {
+        setScalingDev(scalingDev);
+    }
+    
+    public MutateESCorrVector(double scalingDev, double initialVelocity) {
+        setScalingDev(scalingDev);
+        setInitialVelocity(initialVelocity);
+    }
+    
+    public MutateESCorrVector(double scalingDev, double initialVelocity, double rotDev) {
+        setScalingDev(scalingDev);
+        setInitialVelocity(initialVelocity);
+        setRotationDev(rotDev);
+    }
+    
+    public MutateESCorrVector(MutateESCorrVector mutator) {
+        this.m_scalingDev     = mutator.m_scalingDev;
+        this.m_initialVelocity 		= mutator.m_initialVelocity;
+        this.m_LowerLimitStepSize   = mutator.m_LowerLimitStepSize;
+        this.m_rotationDev = mutator.m_rotationDev;
+    }
+    
+    /** This method will enable you to clone a given mutation operator
+     * @return The clone
+     */
+    public Object clone() {
+        return new MutateESCorrVector(this);
+    }
+
+    /** This method allows you to evaluate wether two mutation operators
+     * are actually the same.
+     * @param mutator   The other mutation operator
+     */
+    public boolean equals(Object mutator) {
+        if (mutator instanceof MutateESCorrVector) {
+            MutateESCorrVector mut = (MutateESCorrVector)mutator;
+            if (this.m_scalingDev != mut.m_scalingDev) return false;
+            if (this.m_initialVelocity != m_initialVelocity) return false;
+            if (this.m_LowerLimitStepSize != mut.m_LowerLimitStepSize) return false;
+            return true;
+        } else return false;
+    }
+
+    /** This method allows you to init the mutation operator
+     * @param individual      The individual that will be mutated.
+     * @param opt               The optimization problem.
+     */
+    public void init(AbstractEAIndividual individual, InterfaceOptimizationProblem opt) {
+    	double[] initVelocity = calcInitialVel(m_initialVelocity, ((InterfaceESIndividual)individual).getDoubleRange());
+    	individual.putData(vectorKey, initVelocity);
+    }
+
+    /**
+     * Create a random vector of length relative to the given range given by the velocity parameter.  
+     * 
+     * @param velocity
+     * @param doubleRange
+     * @return
+     */
+    private double[] calcInitialVel(double velocity, double[][] doubleRange) {
+    	double[] initVelocity = Mathematics.randomVector(doubleRange.length, 1.0);
+    	double nrm=Mathematics.norm(initVelocity);
+    	double[] shiftedRange=Mathematics.shiftRange(doubleRange);
+    	// normalize to speed
+    	Mathematics.svMult(velocity/nrm, initVelocity, initVelocity);
+    	// and scale by ranges
+    	Mathematics.vvMultCw(shiftedRange, initVelocity, initVelocity);
+    	// System.out.println(Mathematics.getRelativeLength(initVelocity, doubleRange));
+		return initVelocity;
+	}
+
+	/** This method will mutate a given AbstractEAIndividual. If the individual
+     * doesn't implement InterfaceESIndividual nothing happens.
+     * @param individual    The individual that is to be mutated
+     */
+    public void mutate(AbstractEAIndividual individual) {
+//        if (TRACE) System.out.println("Before Mutate: " + AbstractEAIndividual.getDefaultDataString(individual));
+        if (individual instanceof InterfaceESIndividual) {
+            double[] genes = ((InterfaceESIndividual)individual).getDGenotype();
+            double[][] range = ((InterfaceESIndividual)individual).getDoubleRange();
+            
+            double[] vel = (double[])individual.getData(vectorKey);
+            
+            // mutate the velocity vector and write it back
+            if ((m_scalingDev > 0) || (m_rotationDev > 0)) {
+//            	for (int i = 0; i < vel.length; i++) {
+//            		vel[i] += ((range[i][1] -range[i][0])/2)*RNG.gaussianDouble(this.m_MutationStepSize);
+//            	}
+            	double rotateRad = m_rotationDev*(Math.PI/360.)*RNG.gaussianDouble(1.);
+            	// rotate with a gaussian distribution of deviation rotationDeg 
+            	Mathematics.rotateAllAxes(vel, rotateRad, false); // rotate
+            	double rScale=Math.exp(RNG.gaussianDouble(m_scalingDev));
+            	
+            	if ((m_LowerLimitStepSize > 0) || (m_UpperLimitStepSize > 0) ) {
+            		double stepLen=Mathematics.norm(vel);
+            		if (m_LowerLimitStepSize > 0) rScale=Math.max(rScale, m_LowerLimitStepSize/stepLen);
+            		if (m_UpperLimitStepSize > 0) rScale=Math.min(rScale, m_UpperLimitStepSize/stepLen);
+            	}
+            	
+            	Mathematics.svMult(rScale, vel, vel); // mutate speed 
+
+            	individual.putData(vectorKey, vel);
+            	if (TRACE) System.out.println("rotated by " + rotateRad + ", scaled by " + rScale);
+            	if (TRACE) System.out.println("-- dir is  " + BeanInspector.toString(vel));
+            }
+            
+            // add velocity to the individual
+            Mathematics.vvAdd(genes, vel, genes);
+            
+            // check the range
+            if (m_checkConstraints) Mathematics.projectToRange(genes, range);
+            
+            // write genotype back 
+            ((InterfaceESIndividual)individual).SetDGenotype(genes);
+
+        }
+//        if (TRACE) System.out.println("After Mutate:  " + AbstractEAIndividual.getDefaultDataString(individual));
+    }
+
+    /** This method allows you to perform either crossover on the strategy parameters
+     * or to deal in some other way with the crossover event.
+     * @param indy1     The original mother
+     * @param partners  The original partners
+     */
+    public void crossoverOnStrategyParameters(AbstractEAIndividual indy1, Population partners) {
+        ArrayList<Double> tmpList = new ArrayList<Double>();
+        if (indy1.getMutationOperator() instanceof MutateESCorrVector) tmpList.add(new Double(((MutateESCorrVector)indy1.getMutationOperator()).m_scalingDev));
+        for (int i = 0; i < partners.size(); i++) {
+            if (((AbstractEAIndividual)partners.get(i)).getMutationOperator() instanceof MutateESCorrVector) tmpList.add(new Double(((MutateESCorrVector)((AbstractEAIndividual)partners.get(i)).getMutationOperator()).m_scalingDev));
+        }
+        double[] list = new double[tmpList.size()];
+        for (int i = 0; i < tmpList.size(); i++) list[i] = ((Double)tmpList.get(i)).doubleValue();
+        if (list.length <= 1) return;
+        // discreete mutation for step size
+        this.m_scalingDev = list[RNG.randomInt(0, list.length-1)];
+    }
+
+    /** This method allows you to get a string representation of the mutation
+     * operator
+     * @return A descriptive string.
+     */
+    public String getStringRepresentation() {
+        return "ES global mutation";
+    }
+
+/**********************************************************************************************************************
+ * These are for GUI
+ */
+    /** This method allows the CommonJavaObjectEditorPanel to read the
+     * name to the current object.
+     * @return The name.
+     */
+    public String getName() {
+        return "ES correlated vector mutation";
+    }
+    /** This method returns a global info string
+     * @return description
+     */
+    public String globalInfo() {
+        return "The correlated vector mutation stores a specific mutation vector per individual.";
+    }
+
+    /** Set the initial mutation step size with this method.
+     * @param d   The mutation operator.
+     */
+    public void setScalingDev(double d) {
+        this.m_scalingDev = d;
+    }
+    public double getScalingDev() {
+        return this.m_scalingDev;
+    }
+    public String scalingDevTipText() {
+        return "Choose the devation of lognormal vector scaling.";
+    }
+
+    /** Set the lower limit for the mutation step size with this method.
+     * @param d   The mutation operator.
+     */
+    public void setLowerLimitStepSize(double d) {
+        if (d < 0) d = 0;
+        this.m_LowerLimitStepSize = d;
+    }
+    public double getLowerLimitStepSize() {
+        return this.m_LowerLimitStepSize;
+    }
+    public String lowerLimitStepSizeTipText() {
+        return "Set the lower limit for the mutation step.";
+    }
+
+	public double getRotationDev() {
+		return m_rotationDev;
+	}
+
+	public void setRotationDev(double rotationDeg) {
+		this.m_rotationDev = rotationDeg;
+	}
+	
+	public String rotationDevTipText() {
+		return "Std deviation of the rotation angle distribution";
+	}
+
+	public double getInitialVelocity() {
+		return m_initialVelocity;
+	}
+
+	public void setInitialVelocity(double velocity) {
+		m_initialVelocity = velocity;
+	}
+
+	public double getUpperLimitStepSize() {
+		return m_UpperLimitStepSize;
+	}
+
+	public void setUpperLimitStepSize(double upperLimitStepSize) {
+		m_UpperLimitStepSize = upperLimitStepSize;
+	}
+	
+	public String upperLimitStepSizeTipText() {
+		return "Set the upper limit for the mutation step.";
+	}
+}

src/eva2/server/go/operators/selection/SelectParticleWheel.java

@@ -4,6 +4,7 @@ import eva2.server.go.individuals.AbstractEAIndividual;
 import eva2.server.go.operators.selection.probability.InterfaceSelectionProbability;
 import eva2.server.go.operators.selection.probability.SelProbBoltzman;
 import eva2.server.go.operators.selection.probability.SelProbStandard;
+import eva2.server.go.operators.selection.probability.SelProbStandardScaling;
 import eva2.server.go.populations.Population;
 import wsi.ra.math.RNG;
 
@@ -30,6 +31,14 @@ public class SelectParticleWheel implements InterfaceSelection, java.io.Serializ
     public SelectParticleWheel() {
     }
     
+    public SelectParticleWheel(double scalingProb) {
+    	m_SelProbCalculator = new SelProbStandardScaling(scalingProb);
+    }
+
+    public SelectParticleWheel(InterfaceSelectionProbability selProb) {
+    	m_SelProbCalculator = selProb;
+    }
+
     public SelectParticleWheel(SelectParticleWheel a) {
         this.m_SelProbCalculator    = (InterfaceSelectionProbability)a.m_SelProbCalculator.clone();
         this.m_ObeyDebsConstViolationPrinciple = a.m_ObeyDebsConstViolationPrinciple;

src/eva2/server/go/strategies/ParticleFilterOptimization.java

@@ -1,11 +1,14 @@
 package eva2.server.go.strategies;
 
 
+import eva2.gui.BeanInspector;
+import eva2.gui.GenericObjectEditor;
 import eva2.gui.Plot;
 import eva2.server.go.InterfacePopulationChangedEventListener;
 import eva2.server.go.individuals.AbstractEAIndividual;
 import eva2.server.go.individuals.InterfaceDataTypeDouble;
-import eva2.server.go.individuals.InterfaceESIndividual;
+import eva2.server.go.operators.distancemetric.EuclideanMetric;
+import eva2.server.go.operators.mutation.MutateESCorrVector;
 import eva2.server.go.operators.mutation.MutateESFixedStepSize;
 import eva2.server.go.operators.selection.InterfaceSelection;
 import eva2.server.go.operators.selection.SelectParticleWheel;
@@ -16,7 +19,8 @@ import eva2.server.go.problems.AbstractOptimizationProblem;
 import eva2.server.go.problems.F1Problem;
 import eva2.server.go.problems.InterfaceOptimizationProblem;
 
-/** This is a Particle Filter implemented by Frank Senke, only some documentation
+/**
+ * This is a Particle Filter implemented by Frank Senke, only some documentation
  * here and not completely checked whether this works on arbitrary problem
  * instances. MK did some adaptations, this should work on real valued problems now.
  * 
@@ -37,23 +41,37 @@ public class ParticleFilterOptimization implements InterfaceOptimizer, java.io.S
 	private static final long serialVersionUID = 1L;
 	private Population                      m_Population        = new Population();
     private InterfaceOptimizationProblem    m_Problem           = new F1Problem();
-    private InterfaceSelection              m_ParentSelection   = new SelectParticleWheel();
+    private InterfaceSelection              m_ParentSelection   = new SelectParticleWheel(0.5);
     //private boolean							m_UseElitism		= true;
 
     private String					m_Identifier = "";
     private boolean 				withShow = false;
-    private double					mutationSigma = 0.05;
+    private double					mutationSigma = 0.01;
+    private double					randomImmigrationQuota = 0.05;
+    private double					initialVelocity = 0.02;
+    private double					rotationDeg = 20.;
+    private int						popSize = 300;
 
     private int 					sleepTime = 0;
     
     transient private int indCount = 0;
     transient private InterfacePopulationChangedEventListener m_Listener;
     transient Plot myPlot = null;
+    public static final boolean TRACE = false;
 
     public ParticleFilterOptimization() {
         if (withShow) setWithShow(true);
     }
     
+    public ParticleFilterOptimization(double vInit, double mute, double immiQuote, double rotDeg, double selScaling) {
+    	mutationSigma = mute;
+    	initialVelocity = vInit;
+    	randomImmigrationQuota = immiQuote;
+    	rotationDeg = rotDeg;
+    	m_ParentSelection = new SelectParticleWheel(selScaling);
+        if (withShow) setWithShow(true);
+    }
+    
     public ParticleFilterOptimization(ParticleFilterOptimization a) {
         this.m_Population                   = (Population)a.m_Population.clone();
         this.m_Problem                      = (InterfaceOptimizationProblem)a.m_Problem.clone();
@@ -65,19 +83,28 @@ public class ParticleFilterOptimization implements InterfaceOptimizer, java.io.S
         if (a.withShow) setWithShow(true);
     }
 
+    public void hideHideable() {
+    	GenericObjectEditor.setHideProperty(this.getClass(), "population", true);
+    }
+    
     public Object clone() {
         return (Object) new ParticleFilterOptimization(this);
     }
 
     public void init() {
-        this.m_Problem.initPopulation(this.m_Population);    	
         //System.out.println("popsize is   " + m_Population.size());
         //System.out.println("pops targ is " + m_Population.getPopulationSize());
-        for (int i=0; i<m_Population.size(); i++) {
+    	
-        	((AbstractEAIndividual)m_Population.getIndividual(i)).setMutationOperator(new MutateESFixedStepSize(mutationSigma));
+    	if (initialVelocity <= 0.) {
+    		(((AbstractOptimizationProblem)m_Problem).getIndividualTemplate()).setMutationOperator(new MutateESFixedStepSize(mutationSigma));
+    	} else {
+    		(((AbstractOptimizationProblem)m_Problem).getIndividualTemplate()).setMutationOperator(new MutateESCorrVector(mutationSigma, initialVelocity, rotationDeg));
     	}
+    	m_Population.setPopSize(popSize);
+        this.m_Problem.initPopulation(this.m_Population);
         
         setWithShow(withShow);
+
         this.evaluatePopulation(this.m_Population);  
         this.firePropertyChangedEvent(Population.nextGenerationPerformed);
     }
@@ -111,12 +138,37 @@ public class ParticleFilterOptimization implements InterfaceOptimizer, java.io.S
      */
     protected Population resample(Population pop) {
         Population parents;
+        boolean doImmigr=false;
         
         this.m_ParentSelection.prepareSelection(pop);
         
         // Generate a Population of Parents with Parantselectionmethod.
         // DONT forget cloning -> selection does only shallow copies!
-        parents = (Population)(this.m_ParentSelection.selectFrom(pop, this.m_Population.getPopulationSize())).clone();
+        int targetSize = this.m_Population.getPopulationSize();
+        if (randomImmigrationQuota>0) {
+        	if (randomImmigrationQuota>1.) System.err.println("Error, invalid immigration quota!");
+        	else {
+        		targetSize = (int)(this.m_Population.getPopulationSize() * (1.-randomImmigrationQuota));
+        		targetSize = Math.max(1, targetSize); // guarantee at least one to be selected 
+        		if (targetSize < this.m_Population.getPopulationSize()) doImmigr=true;
+        	}
+        }
+
+        parents = (Population)(this.m_ParentSelection.selectFrom(pop, targetSize)).clone();
+        
+        if (doImmigr) {
+        	// add immigrants
+    		AbstractEAIndividual immi;
+    		int i;
+        	for (i=0; (i+parents.getPopulationSize())<pop.getPopulationSize(); i++) {
+        		immi = (AbstractEAIndividual)pop.getEAIndividual(0).clone();
+        		immi.init(getProblem());
+        		parents.add(immi);
+        	}
+        	parents.synchSize();
+        	if (TRACE) System.out.println("Added " + i + " random individuals");
+        }
+
         parents.SetFunctionCalls(pop.getFunctionCalls());
         parents.setGenerationTo(pop.getGeneration());
         
@@ -146,7 +198,12 @@ public class ParticleFilterOptimization implements InterfaceOptimizer, java.io.S
     			if (useCircles) myPlot.getFunctionArea().drawCircle("", curPosition, graphLabel);
     			else myPlot.setUnconnectedPoint(curPosition[0], curPosition[1], graphLabel);
 //    			myPlot.setConnectedPoint(curPosition[0], curPosition[1], graphLabel);
-
+//    			if ( !useCircles && (pop.getEAIndividual(i).hasData(MutateESCorrVector.vectorKey))) {
+//    				double[] v=(double[])pop.getEAIndividual(i).getData(MutateESCorrVector.vectorKey);
+//    				myPlot.setConnectedPoint(curPosition[0], curPosition[1], graphLabel+5);
+//    				curPosition=Mathematics.vvAdd(v, curPosition);
+//    				myPlot.setConnectedPoint(curPosition[0], curPosition[1], graphLabel+5);
+//    			}
     		}
     	}
 	}
@@ -154,7 +211,7 @@ public class ParticleFilterOptimization implements InterfaceOptimizer, java.io.S
 	protected void applyMotionModel(AbstractEAIndividual indy, double noise) {
     	// this currently only performs a mutation
     	indy.mutate();
-    	indy.SetFitness(0, 0);
+    	indy.resetFitness(0);
     }
     
     /**
@@ -173,6 +230,7 @@ public class ParticleFilterOptimization implements InterfaceOptimizer, java.io.S
 
         // predict step
         predict(nextGeneration);
+        if (TRACE) System.out.println("Speed is  " + BeanInspector.toString(ParticleSwarmOptimization.getPopulationVelSpeed(m_Population, 3, MutateESCorrVector.vectorKey, null, null)) + " popM " + BeanInspector.toString(m_Population.getPopulationMeasures(new EuclideanMetric())));
         
         m_Population = evaluatePopulation(nextGeneration);
         
@@ -266,7 +324,6 @@ public class ParticleFilterOptimization implements InterfaceOptimizer, java.io.S
         return this.m_Population;
     }
     public void setPopulation(Population pop){
-//        if (pop.size()!=pop.getPopulationSize()) pop.fitToSize();
         this.m_Population = pop;
     }
     public String populationTipText() {
@@ -296,6 +353,10 @@ public class ParticleFilterOptimization implements InterfaceOptimizer, java.io.S
 		return withShow;
 	}
 
+	public Plot getPlot() {
+		return myPlot;
+	}
+	
 	protected void clearPlot() {
 		if (myPlot!=null) {
 			myPlot.clearAll();
@@ -356,6 +417,47 @@ public class ParticleFilterOptimization implements InterfaceOptimizer, java.io.S
 	}
 	
 	public String mutationSigmaTipText() {
-		return "The mutation step for the gaussian motion model";
+		return "The (fixed) mutation step for the gaussian motion model";
+	}
+
+	public double getRndImmigrQuota() {
+		return randomImmigrationQuota;
+	}
+
+	public void setRndImmigrQuota(double randomImmigrationQuota) {
+		this.randomImmigrationQuota = randomImmigrationQuota;
+	}
+	
+	public String rndImmigrQuotaTipText() {
+		return "The give ratio of the population will be reinitialized randomly in every iteration.";
+	}
+
+	public double getInitialVelocity() {
+		return initialVelocity;
+	}
+
+	public void setInitialVelocity(double initialVelocity) {
+		this.initialVelocity = initialVelocity;
+	}
+	
+	public String initialVelocityTipText() {
+		return "If > 0, a linear motion model will be applied, otherwise the gaussian model"; 
+	}
+
+	public double getRotationDeg() {
+		return rotationDeg;
+	}
+
+	public void setRotationDeg(double rotationDeg) {
+		this.rotationDeg = rotationDeg;
+	}
+
+	public int getPopSize() {
+		return popSize;
+	}
+
+	public void setPopSize(int popSize) {
+		this.popSize = popSize;
+		m_Population.setPopSize(popSize);
 	}
 }