/*
* Datei: OpsFactory.java
* Autor(en): Lukas K�nig
* Java-Version: 6.0
* Erstellt: 05.05.2009
*
* (c) Lukas K�nig, die Datei unterliegt der LGPL
* -> http://www.gnu.de/lgpl-ger.html
*/
package fmg.fmg8.endlAutomat;
import java.util.Random;
import fmg.fmg8.endlAutomat.fitness.FitnessDrehRicht;
import fmg.fmg8.endlAutomat.fitness.FitnessCollAvoid;
import fmg.fmg8.endlAutomat.fitness.FitnessSwapHalfs;
import fmg.fmg8.endlAutomat.fitness.FitnessVerfahren;
import fmg.fmg8.endlAutomat.fitness.FitnessWallFollow;
import fmg.fmg8.endlAutomat.fitness.FitnessZahnrad;
import fmg.fmg8.endlAutomat.mutation.CondMutVerfahren;
import fmg.fmg8.endlAutomat.mutation.MutArt1VT;
import fmg.fmg8.endlAutomat.mutation.MutationSEQ;
import fmg.fmg8.endlAutomat.mutation.mutSeq.EinzelMutAdd;
import fmg.fmg8.endlAutomat.mutation.mutSeq.MutSeqVerf;
import fmg.fmg8.endlAutomat.mutation.mutSeq.MutationKlWkeit;
import fmg.fmg8.endlAutomat.rekombination.RekTrivial;
import fmg.fmg8.endlAutomat.rekombination.RekVerfahren;
import fmg.fmg8.sonstiges.SonstMeth;
import fmg.fmg8.statistik.Parametersatz;
/**
* @author Lukas K�nig
*
*/
public class OpsFactory {
// Namen f�r Mutationen. *********************************
/**
* Name f�r die Verhaltensmutation 1.
*/
public static final String MUT_SEQ_VERH1 = "seqMutVerh1";
/**
* Name f�r die Translatormutation 1.
*/
public static final String MUT_SEQ_TRANS1 = "seqMutTrans1";
/**
* Name f�r die "alte" Mutation basierend auf der Automatensicht
* und nicht auf Sequenzen.
*/
public static final String MUT_ALT = "alteMut";
/**
* Die Standardverhaltensmutation.
*/
public static final String MUT_VERH_STANDARD = OpsFactory.MUT_SEQ_VERH1;
/**
* Die Standardtranslatormutation.
*/
public static final String MUT_TRANS_STDANDARD = OpsFactory.MUT_SEQ_TRANS1;
// Namen f�r Fitnessverfahren. *********************************
/**
* Fitnessfunktion f�r Kollisionsvermeidung.
*/
public static final String FIT_COLL_AVOID = "collavoid";
/**
* Fitnessfunktion f�r Gatepassing.
*/
public static final String FIT_SWAP_HALFS = "gatepassing";
/**
* Fitnessfunktion f�r Wallfollowing.
*/
public static final String FIT_WALL_FOLLOW = "wallfollow";
/**
* Standardfitness.
*/
public static final String FIT_ZAHNRAD = "zahnrad";
/**
* Fitness f�r die Drehrichtung von Zahnr�dern.
*/
public static final String FIT_DREH_RICHT = "drehrichtung";
/**
* Standardfitness.
*/
public static final String FIT_STANDARD = OpsFactory.FIT_SWAP_HALFS;
// Standardnamen f�r Rekombinationen. *********************************
/**
* Name f�r die triviale Rekombination, die keine �nderung an Genotypen
* vornimmt.
*/
public static final String REK_TRIVIAL = "trivial";
/**
* Standard-Rekombination.
*/
public static final String REK_STANDARD = OpsFactory.REK_TRIVIAL;
/**
* Gibt einen konstanten Mutationsoperator mit dem �bergebenen Namen zur�ck.
*
* @param mutName Der Name des Mutationsoperators.
* @param rand Der Zufallsgenerator.
* @param params Die Parameter.
*
* @return Die konstante Mutation, falls ein Matching mit dem Namen
* gefunden wurde, <code>null</code> sonst.
*/
public static CondMutVerfahren getKonstMut(
final String mutName,
final Random rand,
final Parametersatz params) {
MutSeqVerf mutSeq;
CondMutVerfahren condMut = null;
if (mutName.equalsIgnoreCase(OpsFactory.MUT_SEQ_VERH1)) {
mutSeq = new MutationKlWkeit(
new EinzelMutAdd(rand, params.getMutVerhStdAbw()),
params.getMutVerhWkeit(),
params.getMutMinFaktorVerh(),
params.getMutMaxFaktorVerh(),
params.getMutSeqLenKonstVerh(),
rand);
condMut = new MutationSEQ(mutSeq, true, false);
}
if (mutName.equalsIgnoreCase(OpsFactory.MUT_SEQ_TRANS1)) {
mutSeq = new MutationKlWkeit(
new EinzelMutAdd(rand, params.getMutTransStdAbw()),
params.getMutTransWkeit(),
params.getMutMinFaktorTrans(),
params.getMutMaxFaktorTrans(),
params.getMutSeqLenKonstTrans(),
rand);
condMut = new MutationSEQ(mutSeq, false, true);
}
if (mutName.equalsIgnoreCase(OpsFactory.MUT_ALT)) {
condMut = new MutArt1VT(
rand,
5,
SonstMeth.MODUS_VERHALTEN);
}
if (condMut == null) {
throw new RuntimeException("Operator nicht gefunden.");
}
return condMut;
}
/**
* Gibt einen konstanten Fitnessoperator mit dem �bergebenen Namen
* zur�ck.
*
* @param fitName Der Name des Fitnessverfahren.
*
* @return Das konstante Fitnessverfahren.
*/
public static FitnessVerfahren getKonstFit(
final String fitName) {
FitnessVerfahren fitnessVerfahren = null;
if (fitName.equalsIgnoreCase(OpsFactory.FIT_WALL_FOLLOW)) {
fitnessVerfahren = new FitnessWallFollow();
}
if (fitName.equalsIgnoreCase(OpsFactory.FIT_SWAP_HALFS)) {
fitnessVerfahren = new FitnessSwapHalfs();
}
if (fitName.equalsIgnoreCase(OpsFactory.FIT_COLL_AVOID)) {
fitnessVerfahren = new FitnessCollAvoid();
}
if (fitName.equalsIgnoreCase(OpsFactory.FIT_ZAHNRAD)) {
fitnessVerfahren = new FitnessZahnrad();
}
if (fitName.equalsIgnoreCase(OpsFactory.FIT_DREH_RICHT)) {
fitnessVerfahren = new FitnessDrehRicht();
}
if (fitnessVerfahren == null) {
throw new RuntimeException("Operator nicht gefunden.");
}
return fitnessVerfahren;
}
/**
* Gibt ein Rekombinationsverfahren zur�ck.
*
* @param rekName Der Name der Rekombination.
* @param params Der Parametersatz.
* @param rand Der Zufallsgenerator.
*
* @return Das Rekombinationsverfahren.
*/
public static RekVerfahren getKonstRek(
final String rekName,
final Parametersatz params,
final Random rand) {
RekVerfahren rekombinationsVerfahren = null;
if (rekName.equalsIgnoreCase(OpsFactory.REK_TRIVIAL)) {
rekombinationsVerfahren = new RekTrivial(
params.getRekAnzEltern(),
params.getRekAnzKinder(),
params.getRekNormiert(),
params.getRekMaxPopSize(),
rand);
}
if (rekombinationsVerfahren == null) {
throw new RuntimeException("Operator nicht gefunden.");
}
return rekombinationsVerfahren;
}
}