/*
* Datei: StatMeth.java
* Autor(en): Lukas König
* Java-Version: 6.0
* Erstellt: 03.01.2010
*
* (c) This file and the EAS (Easy Agent Simulation) framework containing it
* is protected by Creative Commons by-nc-sa license. Any altered or
* further developed versions of this file have to meet the agreements
* stated by the license conditions.
*
* In a nutshell
* -------------
* You are free:
* - to Share -- to copy, distribute and transmit the work
* - to Remix -- to adapt the work
*
* Under the following conditions:
* - Attribution -- You must attribute the work in the manner specified by the
* author or licensor (but not in any way that suggests that they endorse
* you or your use of the work).
* - Noncommercial -- You may not use this work for commercial purposes.
* - Share Alike -- If you alter, transform, or build upon this work, you may
* distribute the resulting work only under the same or a similar license to
* this one.
*
* + Detailed license conditions (Germany):
* http://creativecommons.org/licenses/by-nc-sa/3.0/de/
* + Detailed license conditions (unported):
* http://creativecommons.org/licenses/by-nc-sa/3.0/deed.en
*
* This header must be placed in the beginning of any version of this file.
*/
package eas.statistics;
import java.awt.Color;
import java.awt.Polygon;
import java.io.File;
import java.util.ArrayList;
import java.util.LinkedList;
import eas.math.MiscMath;
import eas.math.geometry.Geometry2D;
import eas.math.geometry.Polygon2D;
import eas.math.geometry.Vector2D;
import eas.miscellaneous.StaticMethods;
import eas.miscellaneous.system.FileNamePostfixFilter;
import eas.plugins.standard.eaPlugin.xmlRecording.XMLAufnLesen;
import eas.simulation.spatial.sim2D.marbSimulation.statistik.PopSnapshot;
import eas.startSetup.ParCollection;
import eas.startSetup.marbBuilder.zeichenModi.AusgMerkm;
import eas.startSetup.marbBuilder.zeichenModi.ArrowMaster;
import eas.statistics.resGuete.ResGueteSteigerung;
import eas.statistics.resGuete.ResGueteTest;
/**
* @author Lukas König
*/
public class StatisticMethods {
/**
* Extrahiert die Fitnesswerte der aktuellen Roboter.
*
* @param aufn Die XML-Aufnahme.
*
* @return Die extrahierten Fitnesswerte.
*/
public static String extrahiereFit(
final XMLAufnLesen aufn) {
PopSnapshot pop;
long popNummer;
String sGes = "";
// Erste Zeile.
sGes = sGes + "SnapshotID";
for (int i = 0;
i < aufn.getPop(0).getRobSchnapp().length;
i++) {
sGes = sGes + ";Fitness (Roboter " + i + ")";
}
sGes = sGes + "\n";
// Rest.
for (int i = 0; i < aufn.popNum(); i++) {
String s = "";
pop = aufn.getPop(i);
popNummer = pop.getId();
s = s + popNummer;
for (int j = 0; j < pop.getRobSchnapp().length; j++) {
s = s
+ ";"
+ pop.getRobSchnapp()[j].getFitness()[0];
}
sGes = sGes + s + "\n";
}
return sGes;
}
/**
* Extrahiert alle Fitnesswerte aus allen Statistikdateien im angegebenen
* Verzeichnis.
*
* @param verz Das Verzeichnis, in dem sich die Statistiken
* befinden.
* @param params Die Parameter.
*/
public static void extrahiereAlleFit(
final String verz,
final ParCollection params) {
File pfad = new File(verz);
String endungGZ = "gz";
String endung = "xml";
String[] gespGrGZ = pfad.list(new FileNamePostfixFilter(endungGZ));
String[] gespGr;
if (gespGrGZ == null) {
StaticMethods.log(
StaticMethods.LOG_ERROR,
"Ungueltiges Verzeichnis: " + verz,
params);
throw new RuntimeException("Ungültiges Verzeichnis.\n" + verz);
}
// Entpacke Dateien.
// TODO: Dieser Teil muss eigentlich nur dann passieren,
// wenn die Textdateien noch nicht existieren.
for (String s : gespGrGZ) {
StaticMethods.logInfo("Entpacken " + s + ".", params);
StaticMethods.entpackeDatei(
verz + File.separator + s,
verz + File.separator + StaticMethods.datNamOhneHintErw(s),
true);
}
gespGr = pfad.list(new FileNamePostfixFilter(endung));
XMLAufnLesen aufn;
String sGes;
String zusGes;
for (int i = 0; i < gespGr.length; i++) {
StaticMethods.log(StaticMethods.LOG_INFO,
"Extrahiere Fitness ("
+ verz
+ File.separator
+ gespGr[i]
+ ").",
params);
try {
String fitnessDatei = "FIT-" + gespGr[i] + ".txt";
String zusatzDatei = "ZUS-" + gespGr[i] + ".txt";
if (new File(
verz + File.separator + fitnessDatei).exists()
&& new File(
verz + File.separator + zusatzDatei).exists()) {
// Falls die Ergebnisdateien schon existieren:
StaticMethods.log(
StaticMethods.LOG_INFO,
"Text-Dateien existieren bereits.",
params);
} else {
aufn = new XMLAufnLesen(
new File(
verz
+ File.separator
+ gespGr[i]),
params);
sGes = StatisticMethods.extrahiereFit(aufn);
zusGes = StaticMethods.extrZusatz(aufn);
// Speichere Fitnesswerte.
StaticMethods.speichereTextDatei(
verz,
fitnessDatei,
sGes,
params);
// Speichere Zusatzwerte.
StaticMethods.speichereTextDatei(
verz,
zusatzDatei,
zusGes,
params);
}
// Speichere Schaubilder aus Textdateien. TODO
// StatisticMethods.schaubildAusTextDatei(verz, fitnessDatei, params);
} catch (final Exception e) {
StaticMethods.log(
StaticMethods.LOG_ERROR,
"Fitnesswerte nicht extrahiert: "
+ gespGr[i] + "\n" + e,
params);
}
}
// Entpackte Dateien löschen.
// TODO: Dieser Teil muss eigentlich nur dann passieren,
// wenn die Textdateien noch nicht existiert haben.
for (String datei : gespGr) {
try {
StaticMethods.logInfo("Konsistenz wiederherstellen " + datei + ".gz" + ".", params);
StaticMethods.packeDatei(
verz + File.separator + datei,
verz + File.separator + datei + ".gz",
true);
} catch (Exception e) {
//
}
}
}
/**
* Erzeugt in einer Objekt-Liste das Schaubild der übergebenen
* Werteverläufe.
* Alle Listen, die die Werteverläufe beinhalten, müssen die gleiche Länge
* haben. Der erste Verlauf bezeichnet die Beschriftung der Y-Achse.
*
* @param werte Werteverläufe, wobei eine Liste von Listen von
* Werten erwartet wird. Jede dieser Listen wird
* für sich gezeichnet.
* @param beschriftungen Die Beschriftungen der Y-Achse.
* @param ueberschrift Die überschrift.
* @param gueteTest Der Test der Güte von Resultaten.
* @param params Der Parametersatz.
*
* @return Eine Objektliste, die das Schaubild enthält.
* Falls keine Werte übergeben wurden, wird null zurückgegeben.
* GDW der Güte-Test bestanden wurde, wird als letztes Objekt
* (also Nummer .size() - 1 in der Liste) ein String mit dem Text
* "GOOD" zurückgegeben.
*/
private static LinkedList<Object> erzeugeSchaubild(
final ArrayList<String> beschriftungen,
final ArrayList<ArrayList<Double>> werte,
final String ueberschrift,
final ResGueteTest gueteTest,
final ParCollection params) {
final double hoehe = 960;
final double breite = 1280;
double maxX = -1;
double maxY = Double.MIN_VALUE;
double minY = Double.MAX_VALUE;
double schrittX;
double schrittY;
double dicke = 2;
ArrowMaster master = new ArrowMaster(params);
LinkedList<Object> zeichenObjekte = new LinkedList<Object>();
AusgMerkm[] merkmale = new AusgMerkm[2];
merkmale[0] = new AusgMerkm(Color.black, Color.black, true, true);
merkmale[1] = new AusgMerkm(Color.white, Color.white, false, false);
Polygon2D rahmen = new Polygon2D();
Polygon2D balkenOben = new Polygon2D();
Polygon2D balkenUnten = new Polygon2D();
Polygon2D durchschnitt;
double strichweiteX = 25;
int glAbst = 50; // TODO: Gleitender Durchschnitt.
if (werte == null || werte.size() == 0) {
return null;
}
// Maxima suchen:
for (ArrayList<Double> liste : werte) {
if (maxX < 0) {
maxX = liste.size();
}
if (maxX != liste.size()) {
throw new RuntimeException("Listen haben ungleiche Länge.");
}
for (double d : liste) {
if (d > maxY) {
maxY = d;
}
if (d < minY) {
minY = d;
}
}
}
// Falls Fitnesswerte alle auf einer Konstanten liegen:
if (Math.abs(maxY - minY) < 0.0000001) {
maxY = minY + 0.0000001;
}
rahmen.add(new Vector2D(0, 0));
rahmen.add(new Vector2D(0, hoehe));
rahmen.add(new Vector2D(breite, hoehe));
rahmen.add(new Vector2D(breite, 0));
balkenOben.add(new Vector2D(0, -1));
balkenOben.add(new Vector2D(breite, -1));
balkenOben.add(new Vector2D(breite, -60));
balkenOben.add(new Vector2D(0, -60));
balkenUnten.add(new Vector2D(0, hoehe + 1));
balkenUnten.add(new Vector2D(breite, hoehe + 1));
balkenUnten.add(new Vector2D(breite, hoehe + 60));
balkenUnten.add(new Vector2D(0, hoehe + 60));
schrittX = breite / maxX;
schrittY = hoehe / (maxY - minY);
// Nulllinie:
ArrayList<Double> dicken = new ArrayList<Double>(
(int) Math.round(maxX) + 1);
zeichenObjekte.add(
new AusgMerkm(Color.black, Color.black, true, true));
Polygon2D nulllinie = new Polygon2D();
nulllinie.add(new Vector2D(0, hoehe - (0 - minY) * schrittY));
nulllinie.add(new Vector2D(breite, hoehe - (0 - minY) * schrittY));
Polygon nullPol = master.segmentPfeilPol(
nulllinie,
null,
ArrowMaster.EINFACHER_ABSCHLUSS,
ArrowMaster.EINFACHER_ABSCHLUSS,
new Vector2D(1, 1),
new Vector2D(1, 1),
1,
Vector2D.NULL_VECTOR);
// Einzelne Werte.
zeichenObjekte.add(
new AusgMerkm(Color.LIGHT_GRAY, Color.LIGHT_GRAY, true, true));
for (ArrayList<Double> liste : werte) {
Polygon2D pol = new Polygon2D();
dicken = new ArrayList<Double>(liste.size() + 1);
// Pol2DMitAusgMerkm[] gestrichelt;
double x = 0;
for (double d : liste) {
pol.add(new Vector2D(x, hoehe - (d - minY) * schrittY));
x += schrittX;
}
// pol = pol.normalisiere();
for (int i = 0; i < pol.nPoints(); i++) {
dicken.add(dicke);
}
// gestrichelt = master.gestrichelterPfeil(
// pol,
// dicken,
// PfeilMaster.EINFACHER_ABSCHLUSS,
// PfeilMaster.EINFACHER_ABSCHLUSS,
// new Vektor2D(1, 1),
// new Vektor2D(1, 1),
// merkmale,
// 10000,
// params);
pol = master.segmentPfeilPol2D(
pol,
dicken,
ArrowMaster.EINFACHER_ABSCHLUSS,
ArrowMaster.EINFACHER_ABSCHLUSS,
new Vector2D(1, 1),
new Vector2D(1, 1));
zeichenObjekte.add(pol.toPol());
// for (Pol2DMitAusgMerkm pa : gestrichelt) {
// if (pa != null) {
// zeichenObjekte.add(pa.getAusg());
// zeichenObjekte.add(pa.getPol().toPol());
// }
// }
}
// Durchschnittslinie:
double maxDurch = Double.MIN_VALUE;
double maxGleit = Double.MIN_VALUE;
zeichenObjekte.add(
new AusgMerkm(
Color.black,
new Color(185, 0, 0),
true,
true));
durchschnitt = new Polygon2D();
dicken = new ArrayList<Double>(
(int) Math.round(maxX) + 1);
double x = 0;
for (int i = 0; i < maxX; i++) {
double durchWert = 0;
for (ArrayList<Double> liste : werte) {
durchWert += liste.get(i);
}
durchWert /= werte.size();
if (maxDurch < durchWert) {
maxDurch = durchWert;
}
durchschnitt.add(new Vector2D(x, hoehe - (durchWert - minY) * schrittY));
x += schrittX;
}
// durchschnitt = durchschnitt.normalisiere();
for (int i = 0; i < durchschnitt.nPoints(); i++) {
dicken.add(dicke * 2);
}
Polygon durchPol = master.segmentPfeilPol(
durchschnitt,
dicken,
ArrowMaster.EINFACHER_ABSCHLUSS,
ArrowMaster.EINFACHER_ABSCHLUSS,
new Vector2D(1, 1),
new Vector2D(1, 1),
1,
Vector2D.NULL_VECTOR);
zeichenObjekte.add(durchPol);
// Gleitender Durchschnitt.
ArrayList<Double> durch = new ArrayList<Double>(werte.get(0).size());
ArrayList<Double> dickenGleit = new ArrayList<Double>(durch.size());
for (int i = 0; i < maxX; i++) { // Durchschnitt.
double durchWert = 0;
for (ArrayList<Double> liste : werte) {
durchWert += liste.get(i);
}
durch.add(durchWert / werte.size());
}
ArrayList<Double> gleit = MiscMath.glDurchSchn(durch, glAbst);
// Maximum suchen.
for (double d : gleit) {
if (d > maxGleit) {
maxGleit = d;
}
}
Polygon2D gleitPol = new Polygon2D();
x = schrittX * glAbst;
for (double glWert : gleit) {
gleitPol.add(new Vector2D(x, hoehe - (glWert - minY) * schrittY));
dickenGleit.add(dicke * 4);
x += schrittX;
}
Polygon gleitP = master.segmentPfeilPol(
gleitPol,
dickenGleit,
ArrowMaster.EINFACHER_ABSCHLUSS,
ArrowMaster.EINFACHER_ABSCHLUSS,
new Vector2D(1, 1),
new Vector2D(1, 1),
1,
Vector2D.NULL_VECTOR);
zeichenObjekte.add(
new AusgMerkm(Color.white, Color.black, true, true));
zeichenObjekte.add(gleitP);
// Umrisse und Linien:
zeichenObjekte.add(
new AusgMerkm(Color.white, Color.white, true, true));
zeichenObjekte.add(balkenOben.toPol());
zeichenObjekte.add(balkenUnten.toPol());
zeichenObjekte.add(
new AusgMerkm(Color.black, Color.white, true, false));
zeichenObjekte.add(rahmen.toPol());
zeichenObjekte.add(nullPol);
// Beschriftungen:
if (beschriftungen != null) {
Polygon2D strichPol2D;
Polygon strichPol;
zeichenObjekte.add(new AusgMerkm(
Color.black,
Color.black,
true,
true,
"",
0,
20));
for (double d = 0; d < maxX; d += strichweiteX) {
strichPol2D = new Polygon2D();
dicken = new ArrayList<Double>(2);
strichPol2D.add(new Vector2D(d * schrittX, hoehe - 5));
strichPol2D.add(new Vector2D(d * schrittX, hoehe + 5));
dicken.add(dicke);
dicken.add(dicke);
strichPol = master.segmentPfeilPol(
strichPol2D,
dicken,
ArrowMaster.EINFACHER_ABSCHLUSS,
ArrowMaster.EINFACHER_ABSCHLUSS,
new Vector2D(1, 1),
new Vector2D(1, 1),
1,
Vector2D.NULL_VECTOR);
zeichenObjekte.add((int) (d * schrittX));
zeichenObjekte.add((int) (hoehe + 25));
zeichenObjekte.add(
beschriftungen.get((int) (d)));
zeichenObjekte.add(strichPol);
}
zeichenObjekte.add(0);
zeichenObjekte.add(-10);
zeichenObjekte.add("" + maxY);
// überschrift:
zeichenObjekte.add(0);
zeichenObjekte.add(-40);
zeichenObjekte.add(
ueberschrift
+ " (MaxDurch: "
+ maxDurch
+ " / MaxGleit: "
+ maxGleit
+ ")");
}
// Güte (muss zuletzt kommen!):
if (gueteTest.guteGuete(gleit)) {
zeichenObjekte.add(new AusgMerkm(
Color.red,
Color.red,
true,
true,
"",
0,
20));
zeichenObjekte.add(70);
zeichenObjekte.add(-10);
zeichenObjekte.add("GOOD");
}
return zeichenObjekte;
}
/**
* Erzeugt eine PNG-Datei mit dem Schaubild aus der übergebenen Datei.
*
* @param verz Das Verzeichnis.
* @param dateiname Die Datei.
* @param params Die Parameter.
*/
public static void schaubildAusTextDatei(
final String verz,
final String dateiname,
final ParCollection params) {
String altVerz = params.getStdDirectory();
ArrayList<ArrayList<Double>> werte = new ArrayList<ArrayList<Double>>();
LinkedList<String> daten;
String[] einzDaten;
ArrayList<String> yAchse = new ArrayList<String>();
LinkedList<Object> zeichenObjekte;
String dateiZusatz;
params.setStdDirectory(verz);
daten = StaticMethods.liesTextArray(verz, dateiname, params);
for (String satz : daten) {
einzDaten = satz.split(";");
if (werte.size() == 0) {
for (int i = 1; i < einzDaten.length; i++) {
werte.add(new ArrayList<Double>());
}
}
for (int i = 1; i < einzDaten.length; i++) {
try {
werte.get(i - 1).add(Double.parseDouble(einzDaten[i]));
if (i == 1) {
yAchse.add(einzDaten[0]);
}
} catch (final Exception e) {
StaticMethods.log(
StaticMethods.LOG_STAGE1,
"nicht geparst: " + einzDaten[i],
params);
}
}
}
zeichenObjekte = StatisticMethods.erzeugeSchaubild(
yAchse,
werte,
dateiname,
new ResGueteSteigerung(15),
params);
if (zeichenObjekte.get(zeichenObjekte.size() - 1).equals("GOOD")) {
dateiZusatz = "_GOOD";
} else {
dateiZusatz = "";
}
// Löschen der alten Dateien:
if (new File(
params.getStdDirectory()
+ File.separator
+ dateiname
+ "_GOOD"
+ ".png").exists()) {
StaticMethods.deleteDAT(params.getStdDirectory() + File.separator + dateiname + "_GOOD" + ".png");
}
if (new File(
params.getStdDirectory()
+ File.separator
+ dateiname
+ ".png").exists()) {
StaticMethods.deleteDAT(params.getStdDirectory() + File.separator + dateiname + ".png");
}
Geometry2D.saveObjectsToFile(
zeichenObjekte,
dateiname + dateiZusatz + ".png",
"png",
params);
params.setStdDirectory(altVerz);
}
/**
* Schreibt die Info-Datei für diesen Lauf.
*
* @param params Die Parameter.
* @param xmlAufnDat Name der XML-Datei.
*/
public static void schreibeInfoDatei(
final ParCollection params,
final String xmlAufnDat) {
String s = "Informationsdatei für " + xmlAufnDat + "\n\n";
String dateiname;
String verzeichnis;
s += "\nEs folgt eine Ausgabe des kompletten Parametersatzes:\n\n";
s += params.toString();
dateiname = xmlAufnDat;
// for (String herv : hervor) {
// wert = params.getParWert(herv).toString();
// wert = wert.replace(':', '-');
// dateiname += // "_" + herv +
// "_" + wert;
// if (dateiname.length() > 130) {
// break;
// }
// }
dateiname += "_info.txt";
verzeichnis = params.getStdDirectory();
StaticMethods.speichereTextDatei(
verzeichnis,
dateiname,
s,
params);
StaticMethods.log(
StaticMethods.LOG_INFO,
"Infodatei für diesen Lauf: "
+ verzeichnis
+ File.separatorChar
+ dateiname,
params);
}
/**
* Speichert die Durchschnittsverläufe für die übergebene Liste von Dateien
* in eine neue Datei. Die Zeilenbeschriftungen werden aus der ersten Datei
* genommen. Es wird zum Schluss auch eine Schaubildgrafik erzeugt.
*
* @param verzeichnis Das Verzeichnis, in dem die Operationen
* durchgeführt werden sollen.
* @param quelldateien Die Quelldateien, aus denen die einzelnen
* Durchschnittsverläufe gebildet werden sollen.
* @param zieldatei Die Datei, in der die Durchschnittsverläufe
* gespeichert werden sollen.
* @param trennzeichen Das Trennzeichen, mit dem die Werte in den Dateien
* voneinander getrennt sind.
* @param params Die Parameter.
*/
@SuppressWarnings({ "unchecked" })
public static void erzeugeDurchDatei(
final String verzeichnis,
final String[] quelldateien,
final String zieldatei,
final String trennzeichen,
final ParCollection params) {
ArrayList<Double>[] durchLaeufe = new ArrayList[quelldateien.length];
ArrayList<String> beschriftungen = new ArrayList<String>();
LinkedList<String> einzelDatei;
double durch;
int i = 0;
int max = 0;
int maxVerlauf = 0;
double summe;
double anzahl;
ArrayList<String> ausgabe;
String zeileAusg;
String[] werteString;
String[] gesString;
if (quelldateien.length < 1) {
return;
}
// Durchschnittsverläufe berechnen.
for (String f : quelldateien) {
einzelDatei = StaticMethods.liesTextArray(verzeichnis, f, params);
durchLaeufe[i] = new ArrayList<Double>(einzelDatei.size());
for (String zeile : einzelDatei) {
try {
gesString = zeile.split(trennzeichen);
werteString = new String[gesString.length - 1];
for (int j = 0; j < werteString.length; j++) {
werteString[j] = gesString[j + 1];
}
durch = StatisticMethods.durchschnitt(werteString);
durchLaeufe[i].add(durch);
} catch (final Exception e) {
StaticMethods.log(
StaticMethods.LOG_DEBUG,
"Zeile nicht eingefügt aus " + f + ".",
params);
}
}
if (durchLaeufe[i].size() > max) {
max = durchLaeufe[i].size();
maxVerlauf = i;
}
i++;
}
// Beschriftungen extrahieren (erste Zeile ignorieren).
einzelDatei = StaticMethods.liesTextArray(
verzeichnis,
quelldateien[maxVerlauf],
params);
for (int j = 1; j < einzelDatei.size(); j++) {
String zeile = einzelDatei.get(j);
beschriftungen.add(zeile.split(trennzeichen)[0]);
}
beschriftungen.add("");
// Zu kurze Verläufe mit Mittelwert der anderen auff�llen.
for (ArrayList<Double> durchLauf : durchLaeufe) {
if (durchLauf.size() < max) {
for (int j = durchLauf.size(); j < max; j++) {
summe = 0;
anzahl = 0;
// Mittewert der Verläufe berechnen, die lang genug sind.
for (ArrayList<Double> durchLauf2 : durchLaeufe) {
if (durchLauf2.size() > j) {
summe += durchLauf2.get(j);
anzahl++;
}
}
durchLauf.add(summe / anzahl);
}
}
}
/*
* Zu diesem Zeitpunkt gibt es eine Liste von Durchschnittsverläufen,
* die alle gleich lang sind und eine Liste von Beschriftungen
* derselben Länge.
*/
// Transponieren.
ausgabe = new ArrayList<String>(durchLaeufe[0].size());
for (int j = 0; j < durchLaeufe[0].size(); j++) {
zeileAusg = beschriftungen.get(j) + trennzeichen;
for (int k = 0; k < durchLaeufe.length - 1; k++) {
zeileAusg += durchLaeufe[k].get(j) + trennzeichen;
}
zeileAusg += durchLaeufe[durchLaeufe.length - 1].get(j);
ausgabe.add(zeileAusg);
}
StaticMethods.speichereTextAusArray(
verzeichnis,
zieldatei,
ausgabe,
params);
StatisticMethods.schaubildAusTextDatei(verzeichnis, zieldatei, params);
}
/**
* Berechnet den Durchschnitt der übergebenen Werte. Diese sind als String
* zu übergeben!
*
* @param werte Die Werte.
* @return Der Durchschnitt.
*/
private static double durchschnitt(final String[] werte) {
double summe = 0;
for (String wert : werte) {
summe += Double.parseDouble(wert);
}
return summe / werte.length;
}
// AUSWERTUNGEN ZUSAMMENFASSEN:
//
// private static ArrayList<String> getGleiche(final String muster) {
// ArrayList<String> ausgabe = new ArrayList<String>();
// File verzeichnis = new File("C:\\Eig\\Forschung\\Paper_Vortraege\\Paper_7_GECCO\\Experimente\\simTransAlter\\Stat_Infos");
// String muster2 = "";
//
// for (String s : verzeichnis.list()) {
// if (s.substring(20, 23).equals(muster)) {
// muster2 = s.substring(23);
// }
// }
// for (String s : verzeichnis.list()) {
// if (s.substring(23).equals(muster2)) {
// ausgabe.add(s.substring(20, 23));
// }
// }
//
// return ausgabe;
// }
//
// public static void main(String[] args) {
// Parametersatz params = new Parametersatz(args);
// params.ergaenze();
// ArrayList<String> muster;
// String verzeichnis = "C:\\Eig\\Forschung\\Paper_Vortraege\\Paper_7_GECCO\\Experimente\\simTransAlter";
// String zieldatei;
// String trennzeichen = ";";
// String[] quelldateien = null;
// File temp;
// ArrayList<String> qDat = new ArrayList<String>();
//
// for (int i = 0; i <= 647; i++) {
// muster = SonstMeth.getGleiche(SonstMeth.normZahl(i, 3));
// qDat.clear();
// temp = new File(verzeichnis);
// for (String s : temp.list()) {
// if (s.subSequence(0, 3).equals("FIT") && s.endsWith("txt")) {
// for (String s2 : muster) {
// if (s.substring(24, 27).equals(s2)) {
// System.out.println(s);
// qDat.add(s);
// }
// }
// }
// }
//
// quelldateien = new String[qDat.size()];
// int ii = 0;
// for (String s : qDat) {
// quelldateien[ii] = s;
// ii++;
// }
//
// zieldatei = "durchschnitt";
//
// for (String s : quelldateien) {
// String zwisch = SonstMeth.getFileNameWithoutExtension(s);
// zieldatei += "_" + zwisch.substring(zwisch.length() - 4);
// }
// zieldatei += ".txt";
//
// SonstMeth.erzeugeDurchDatei(
// verzeichnis,
// quelldateien,
// zieldatei,
// trennzeichen,
// params);
// }
// }
}