/*
* Datei: RekEinPunkt.java
* Autor(en): Lukas K�nig
* Java-Version: 6.0
* Erstellt: 22.10.2009
*
* (c) Lukas K�nig, die Datei unterliegt der LGPL
* -> http://www.gnu.de/lgpl-ger.html
*/
package fmg.fmg8.endlAutomat.rekombination;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Random;
import fmg.fmg8.endlAutomat.RobCode;
//import fmg.fmg8.endlAutomat.conditions.Condition;
import fmg.fmg8.statistik.Parametersatz;
import fmg.fmg8.umgebung2D.Roboter;
/**
* @author Lukas K�nig
*
*/
public class RekEinPunkt implements RekVerfahren {
// /**
// * Die Anzahl der Eltern.
// */
// private int anzElt;
// /**
// * Der Zufallsgenerator.
// */
// private Random rand;
/**
* @param anzEltern Die Anzahl der Eltern f�r die Rekombination.
* @param random Der Zufallsgenerator.
*/
public RekEinPunkt(final int anzEltern, final Random random) {
super();
// this.anzElt = anzEltern;
// this.rand = random;
}
/**
* Erzeugt aus einer Liste von ZWEI Eltern-Codes ZWEI Kind-Codes durch
* Anwenden eines Ein-Punkt-Rekombinationsoperators.
*
* @param eltern Die Elterncodes.
* @param random Der Zufallsgenerator.
*
* @return Die Kindercodes.
*/
public LinkedList<LinkedList<Integer>> einPunkt(
final LinkedList<LinkedList<Integer>> eltern,
final Random random) {
LinkedList<Integer> eltern1;
LinkedList<Integer> eltern2;
LinkedList<Integer> kind1;
LinkedList<Integer> kind2;
LinkedList<LinkedList<Integer>> kinder
= new LinkedList<LinkedList<Integer>>();
int punkt1;
int punkt2;
if (eltern == null || eltern.size() != 2) {
throw new RuntimeException(
"Falsche Elternanzahl f�r Rekombination.");
}
eltern1 = eltern.get(0);
eltern2 = eltern.get(1);
if (eltern1.size() > 0) {
punkt1 = random.nextInt(eltern1.size());
} else {
punkt1 = 0;
}
if (eltern2.size() > 0) {
punkt2 = random.nextInt(eltern2.size());
} else {
punkt2 = 0;
}
kind1 = new LinkedList<Integer>();
kind2 = new LinkedList<Integer>();
for (int i = 0; i < punkt1; i++) {
kind1.add(eltern1.get(i));
}
for (int i = 0; i < punkt2; i++) {
kind2.add(eltern2.get(i));
}
for (int i = punkt1; i < eltern1.size(); i++) {
kind2.add(eltern1.get(i));
}
for (int i = punkt2; i < eltern2.size(); i++) {
kind1.add(eltern2.get(i));
}
kinder.add(kind1);
kinder.add(kind2);
return kinder;
}
/**
* Methode zum Rekombinieren beliebig vieler Roboter zu EINEM Kindroboter.
* Der beste und zweitbeste Roboter werden durch einen Ein-Punkt-Crossover
* verkn�pft. Welches der beiden m�glichen Kinder weitergegeben wird, wird
* gleichverteilt zuf�llig bestimmt. Es m�ssen mindestens zwei Roboter
* �bergeben werden. ACHTUNG: Es darf nur ein Automat pro Roboter
* vorhanden sein.
*
* @param eltern Die Eltern-Roboter.
*
* @return Die neue Roboterliste als Tupel (ID, Fitness, Code).
*/
@Override
public RobCode[] rekombEinz(final Roboter[] eltern) {
// RobCode[] robcodes = new RobCode[1];
int best, zweitbest;
long besteFit, zweitbesteFit;
// LinkedList<LinkedList<Integer>> rekKinder;
LinkedList<LinkedList<Integer>> rekEltern;
// Fehler, falls eltern.length < 2 || Automatenzahl != 1.
if (eltern[0].getFitVs().length != 1
|| eltern[1].getFitVs().length != 1) {
throw new RuntimeException(
"Fitnessverfahten RekEinPunkt nicht f�r MORO ausgelegt");
}
// Initialisieren.
if (eltern[0].getFitness()[0] >= eltern[1].getFitness()[0]) {
best = 0;
zweitbest = 1;
besteFit = eltern[0].getFitness()[0];
zweitbesteFit = eltern[1].getFitness()[0];
} else {
best = 1;
zweitbest = 0;
besteFit = eltern[1].getFitness()[0];
zweitbesteFit = eltern[0].getFitness()[0];
}
// Den besten und zweitbesten suchen.
for (int i = 0; i < eltern.length; i++) {
if (eltern[i].getFitness()[0] > besteFit) {
zweitbest = best;
zweitbesteFit = besteFit;
besteFit = eltern[i].getFitness()[0];
best = i;
} else if (eltern[i].getFitness()[0] > zweitbesteFit
&& i != best) {
zweitbesteFit = eltern[i].getFitness()[0];
zweitbest = i;
}
}
rekEltern = new LinkedList<LinkedList<Integer>>();
rekEltern.add(eltern[best].erzeugeSequenz(0));
rekEltern.add(eltern[zweitbest].erzeugeSequenz(0));
// rekKinder = this.einPunkt(rekEltern, this.rand);
int[] fits = new int[1];
fits[0] = 0;
// robcodes[0] = new RobCode(
// eltern[best].getId(),
// fits,
//
// );
return null;
}
/**
* F�hrt eine Rekombination der gesamten Population durch. Die
* Rekombination geschieht auf Basis der Methode <code>rekombEinz</code>.
*
* @param pop Die zu rekombinierende Population von Robotern.
*
* @return Die rekombinierte Population.
*/
@Override
public ArrayList<RobCode> rekombiniere(final ArrayList<Roboter> pop) {
return null;
}
/**
* @param args nichts.
*/
public static void main(final String[] args) {
int max = 10;
Roboter[] robs = new Roboter[max];
Parametersatz pars = new Parametersatz(args);
pars.ergaenze();
for (int i = 0; i < max; i++) {
robs[i] = new Roboter(
1,
1,
1,
1,
1,
null,
null,
null,
null,
1,
pars,
null,
true,
null,
null,
1,
null);
robs[i].erzeugeAusSequenz(
0,
i + " " + i + " " + i + " " + i,
null,
null,
false);
// robs[i].setFitVerboten((int) Math.min(i, 50));
}
new RekEinPunkt(2, new Random()).rekombEinz(robs);
}
}