/*
* Datei: RekSEQ.java
* Autor(en): Lukas K�nig
* Java-Version: 6.0
* Erstellt: 12.03.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.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Random;
import fmg.fmg8.endlAutomat.RobCode;
import fmg.fmg8.sonstiges.MathMeth;
import fmg.fmg8.sonstiges.SonstMeth;
import fmg.fmg8.umgebung2D.Roboter;
/**
* @author Lukas K�nig
*/
@Deprecated
public class RekSEQNurErstAut implements RekVerfahren {
/**
* Zufall.
*/
private Random rand;
/**
* Die Anzahl der auf einmal rekombinierten Eltern.
*/
private int anzElt;
/**
* Konstruktor.
*
* @param eltern Die Anzahl der Eltern, die zu einem Kind werden.
* @param random Zufall.
*/
@Deprecated
public RekSEQNurErstAut(
final int eltern,
final Random random) {
this.anzElt = eltern;
this.rand = random;
throw new RuntimeException("Diese Rekombination ist nicht ausgew�hlt.");
}
/**
* Rekombiniert eine Liste von String-Sequenzen zu EINEM Kind anhand
* eines trivialen Crossovers, der nur die Verteilung der Genome, aber
* nicht ihre Struktur ver�ndert. F�r die neue Verteilung wird eine
* proportionale Verteilung auf den �bergebenen Fitnesswerten zugrunde
* gelegt.
*
* @param rob Die zu rekombinierenden Roboter.
*
* @return Die rekombinierten Robotercodes.
*/
@Override
@SuppressWarnings(value = { "unchecked" })
@Deprecated
public RobCode[] rekombEinz(final Roboter[] rob) {
RobCode[] neuerRob = new RobCode[1];
int[] neueFit = new int[0];
ArrayList<Long> vert = new ArrayList<Long>(rob.length);
Integer[] nummern = new Integer[rob.length];
int aktNum;
LinkedList<Integer>[] verhCodes = new LinkedList[1];
LinkedList<Integer>[] transCodes = new LinkedList[1];
for (int i = 0; i < rob.length; i++) {
nummern[i] = i;
if (rob[i].getFitness()[0] >= 0) {
vert.add((long) rob[i].getFitness()[0]);
} else {
vert.add(0L);
}
}
aktNum = (Integer) MathMeth.randVerteilung(
nummern,
vert,
this.rand);
verhCodes[0] = rob[aktNum].getVerhCodes()[0];
transCodes[0] = rob[aktNum].getTransCodes()[0];
neueFit[0] = rob[aktNum].getFitness()[0];
neuerRob[0] = new RobCode(
rob[aktNum].getId(),
neueFit,
null,
rob[aktNum].getConds(),
null,
SonstMeth.stringAusListSeqs(transCodes),
SonstMeth.stringAusListSeqs(verhCodes)
);
return neuerRob;
}
/**
* F�hrt eine Rekombination der gesamten Population durch. Die
* Rekombination geschieht auf Basis der Methode <code>rekombEinz</code>.
* Es werden die am n�chsten zusammenstehenden Roboter rekombiniert.
* <BR>
* Zu beachten ist, dass von JEDEM Roboter aus einmal die n�chsten
* berechnet und diese zusammen zu EINEM Kind rekombiniert werden.
* Die Population bleibt immer gleicher Gr��e.
*
* @param elternPop Die zu rekombinierende Population von Robotern.
*
* @return Die rekombinierte Population als RobCode.
*/
@Deprecated
public ArrayList<RobCode> rekombiniere(
final ArrayList<Roboter> elternPop) {
final int kindAnz = 1;
Iterator<Roboter> it;
Roboter rob1;
Roboter rob2;
Roboter[] eltern = new Roboter[this.anzElt];
RobCode[] kinder;
ArrayList<RobCode> kindPop = new ArrayList<RobCode>();
HashSet<Roboter> nicht = new HashSet<Roboter>(this.anzElt);
it = elternPop.iterator();
while (it.hasNext()) {
nicht.clear();
rob1 = it.next();
eltern[0] = rob1;
nicht.add(rob1);
for (int i = 1; i < this.anzElt; i++) {
rob2 = rob1.getUmg().holeNahenNorm(
(int) rob1.getPosition().x,
(int) rob1.getPosition().y,
nicht);
if (rob2 == null) {
rob2 = rob1;
}
nicht.add(rob2);
eltern[i] = rob2;
}
kinder = this.rekombEinz(eltern);
for (int i = 0; i < kindAnz; i++) {
kindPop.add(kinder[i]);
}
}
return kindPop;
}
}