halfdan/eva2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Further refactoring to clear up package structure.

Browse Source
This commit is contained in:
Fabian Becker
2013-07-19 16:44:59 +02:00
parent a4c45b6295
commit 85ec784da2
19 changed files with 1363 additions and 1694 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
ant/build.xml
View File

@@ -345,7 +345,7 @@
<jar jarfile="${bin.dist.dir}/${library.directory}/EvA2Base.jar" basedir="${build.directory}">
<!--<fileset dir="${classes.dir}" excludes="*test*"/>-->
<manifest> <attribute name="Main-Class" value="eva2.client.EvAClient"/> </manifest>
<manifest> <attribute name="Main-Class" value="eva2.gui.Main"/> </manifest>
</jar>
</target>
@@ -372,7 +372,7 @@
<!-- <fileset dir="${classes.dir}" excludes="*test*"/>
-->
<manifest>
<attribute name="Main-Class" value="eva2.client.EvAClient" />
<attribute name="Main-Class" value="eva2.gui.Main" />
</manifest>
</jar>
</target>
@@ -389,7 +389,7 @@
<jar jarfile="${bin.dist.dir}/${jar.name}.jar" basedir="${build.directory}" >
<manifest>
<attribute name="Main-Class" value="eva2.client.EvAClient"/>
<attribute name="Main-Class" value="eva2.gui.Main"/>
<attribute name="Built-By" value="Center for Bioinformatics Tuebingen (ZBIT)"/>
<!--
<attribute name="Xdock:name" value="EvA2"/>
@@ -662,7 +662,7 @@
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
<target name="run" description="Runs EvA2.">
<java classname="eva2.client.EvAClient" fork="yes">
<java classname="eva2.gui.Main" fork="yes">
<jvmarg value="-Xmx512m"/>
<classpath>
<pathelement path="${project.class.path}" />

4
ant/miniBuild.xml
View File

@@ -255,7 +255,7 @@
</delete>
<jar jarfile="${bin.dist.dir}/${jar.name}.jar" basedir="${build.directory}" >
<manifest> <attribute name="Main-Class" value="eva2.client.EvAClient"/> </manifest>
<manifest> <attribute name="Main-Class" value="eva2.gui.Main"/> </manifest>
</jar>
<copy todir="${distribution.directory}">
@@ -333,7 +333,7 @@
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
<target name="run" description="Runs EvA2.">
<java classname="eva2.client.EvAClient" fork="yes">
<java classname="eva2.gui.Main" fork="yes">
<jvmarg value="-Xmx512m"/>
<classpath>
<pathelement path="${project.class.path}" />

4
pom.xml
View File

@@ -68,7 +68,7 @@
<addMavenDescriptor>false</addMavenDescriptor>
<manifest>
<addClasspath>true</addClasspath>
<mainClass>eva2.client.EvAClient</mainClass>
<mainClass>eva2.gui.Main</mainClass>
</manifest>
</archive>
</configuration>
@@ -92,7 +92,7 @@
</descriptorRefs>
<archive>
<manifest>
<mainClass>eva2.client.EvAClient</mainClass>
<mainClass>eva2.gui.Main</mainClass>
</manifest>
</archive>
</configuration>

127
src/eva2/client/EvAClient.java → src/eva2/gui/Main.java
View File

@@ -1,24 +1,13 @@
package eva2.client;
package eva2.gui;
/*
* Title: EvA2
* Description: The main client class of the EvA framework.
* Copyright: Copyright (c) 2008
* Company: University of Tuebingen, Computer
* Architecture
*
* @author Holger Ulmer, Felix Streichert, Hannes Planatscher
* @version: $Revision: 322 $ $Date: 2007-12-11 17:24:07 +0100 (Tue, 11 Dec 2007)$
* $Author: mkron $
*/
import eva2.EvAInfo;
import eva2.gui.*;
import eva2.client.*;
import eva2.optimization.OptimizationStateListener;
import eva2.optimization.go.InterfaceOptimizationParameters;
import eva2.optimization.modules.AbstractModuleAdapter;
import eva2.optimization.modules.OptimizationParameters;
import eva2.optimization.modules.GenericModuleAdapter;
import eva2.optimization.modules.ModuleAdapter;
import eva2.optimization.modules.OptimizationParameters;
import eva2.optimization.stat.AbstractStatistics;
import eva2.optimization.stat.InterfaceStatisticsListener;
import eva2.optimization.stat.InterfaceStatisticsParameter;
@@ -26,22 +15,22 @@ import eva2.tools.BasicResourceLoader;
import eva2.tools.EVAERROR;
import eva2.tools.ReflectPackage;
import eva2.tools.StringTools;
import javax.help.HelpSet;
import javax.help.JHelpContentViewer;
import javax.help.JHelpNavigator;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.help.*;
import javax.swing.*;
/**
*
*/
public class EvAClient extends JFrame implements OptimizationStateListener {
public class Main extends JFrame implements OptimizationStateListener {
/**
* Generated serial version identifier.
@@ -70,7 +59,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
// LogPanel
private LoggingPanel logPanel;
private static final Logger LOGGER = Logger.getLogger(EvAClient.class.getName());
private static final Logger LOGGER = Logger.getLogger(Main.class.getName());
// Module:
private ExtAction actModuleLoad;
@@ -101,7 +90,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
private EvATabbedFrameMaker frameMaker = null;
private Window parentWindow;
private List<OptimizationStateListener> superListenerList = null;
private java.util.List<OptimizationStateListener> superListenerList = null;
private EvAComAdapter comAdapter;
@@ -123,67 +112,67 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
/**
* Constructor of GUI of EvA2. Works as client for the EvA2 server. Note
* that the EvAClient initialized multi-threaded for efficiency. Use {@link #awaitGuiInitialized()}
* that the Main initialized multi-threaded for efficiency. Use {@link #awaitGuiInitialized()}
* to await full initialization if necessary.
*
*/
public EvAClient(final String hostName) {
public Main(final String hostName) {
this(hostName, null, false, false);
}
/**
* A constructor. Splash screen is optional, Gui is activated, no parent
* window. Note that the EvAClient initialized multi-threaded for
* window. Note that the Main initialized multi-threaded for
* efficiency. Use {@link #awaitGuiInitialized()} to await full
* initialization if necessary.
*
* @see #EvAClient(String, Window, String, boolean, boolean, boolean)
* @see #EvAClient(String, java.awt.Window, String, boolean, boolean, boolean)
* @param hostName
* @param paramsFile
* @param autorun
* @param nosplash
*/
public EvAClient(final String hostName, final String paramsFile, boolean autorun, boolean nosplash) {
public Main(final String hostName, final String paramsFile, boolean autorun, boolean nosplash) {
this(hostName, null, paramsFile, null, autorun, nosplash, false, false);
}
/**
* A constructor with optional spash screen. Note that the EvAClient is
* A constructor with optional spash screen. Note that the Main is
* initialized multi-threaded for efficiency. Use {@link #awaitGuiInitialized()}
* to await full initialization if necessary.
*
* @see #EvAClient(String, String, boolean, boolean)
* @see #Main(String, String, boolean, boolean)
*
* @param hostName
* @param autorun
* @param nosplash
*/
public EvAClient(final String hostName, boolean autorun, boolean nosplash) {
public Main(final String hostName, boolean autorun, boolean nosplash) {
this(hostName, null, autorun, nosplash);
}
/**
* A constructor with optional splash screen. Note that the EvAClient
* A constructor with optional splash screen. Note that the Main
* initialized multi-threaded for efficiency. Use {@link #awaitGuiInitialized()}
* to await full initialization if necessary.
*
* @see #EvAClient(String, String, boolean, boolean)
* @see #Main(String, String, boolean, boolean)
* @param hostName
* @param paramsFile
* @param autorun
* @param noSplash
* @param noGui
*/
public EvAClient(final String hostName, String paramsFile, boolean autorun, boolean noSplash, boolean noGui, boolean withTreeView) {
public Main(final String hostName, String paramsFile, boolean autorun, boolean noSplash, boolean noGui, boolean withTreeView) {
this(hostName, null, paramsFile, null, autorun, noSplash, noGui, withTreeView);
}
/**
* A constructor with optional splash screen. Note that the EvAClient
* A constructor with optional splash screen. Note that the Main
* initialized multi-threaded for efficiency. Use {@link #awaitGuiInitialized()}
* to await full initialization if necessary.
*
* @see #EvAClient(String, String, boolean, boolean)
* @see #Main(String, String, boolean, boolean)
*
* @param hostName
* @param paramsFile
@@ -191,7 +180,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
* @param noSplash
* @param noGui
*/
public EvAClient(final String hostName, InterfaceOptimizationParameters goParams, boolean autorun, boolean noSplash, boolean noGui) {
public Main(final String hostName, InterfaceOptimizationParameters goParams, boolean autorun, boolean noSplash, boolean noGui) {
this(hostName, null, null, goParams, autorun, noSplash, noGui, false);
}
@@ -206,7 +195,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
* @param noSplash
* @param noGui
*/
public EvAClient(final String hostName, final Window parent, final String paramsFile, final InterfaceOptimizationParameters goParams, final boolean autorun, final boolean noSplash, final boolean noGui) {
public Main(final String hostName, final Window parent, final String paramsFile, final InterfaceOptimizationParameters goParams, final boolean autorun, final boolean noSplash, final boolean noGui) {
this(hostName, parent, paramsFile, goParams, autorun, noSplash, noGui, false);
}
@@ -215,7 +204,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
* locally or as client for the EvA2 server. GO parameters may be loaded
* from a file (paramsFile) or given directly as a java instance. Both may
* be null to start with standard parameters. If both are non null, the java
* instance has the higher priority. Note that the EvAClient initialized
* instance has the higher priority. Note that the Main initialized
* multi-threaded for efficiency. Use {@link #awaitGuiInitialized()} to
* await full initialization if necessary.
*
@@ -226,9 +215,9 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
* @param noSplash
* @param noGui
*/
public EvAClient(final String hostName, final Window parent, final String paramsFile, final InterfaceOptimizationParameters goParams, final boolean autorun, final boolean noSplash, final boolean noGui, final boolean showTreeView) {
public Main(final String hostName, final Window parent, final String paramsFile, final InterfaceOptimizationParameters goParams, final boolean autorun, final boolean noSplash, final boolean noGui, final boolean showTreeView) {
clientInited = false;
final SplashScreen splashScreen = new SplashScreen(EvAInfo.splashLocation);
final eva2.gui.SplashScreen splashScreen = new eva2.gui.SplashScreen(EvAInfo.splashLocation);
// preload some classes (into system cache) in a parallel thread
preloadClasses();
@@ -294,7 +283,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
/**
* Since the constructor runs multi-threaded for efficiency, this method may
* be called to await the full initialization of a client instance. As soon
* as it returns, the EvAClient GUI is fully initialized.
* as it returns, the Main GUI is fully initialized.
*/
public void awaitClientInitialized() {
if (initRnbl != null) {
@@ -338,7 +327,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
* @param fontResource The FontUIResource for the controls
*/
private static void setUIFont(javax.swing.plaf.FontUIResource fontResource) {
java.util.Enumeration keys = UIManager.getDefaults().keys();
Enumeration keys = UIManager.getDefaults().keys();
while (keys.hasMoreElements()) {
Object key = keys.nextElement();
Object value = UIManager.get(key);
@@ -509,12 +498,12 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
@Override
public void windowClosing(final WindowEvent event) {
int result = JOptionPane.showConfirmDialog(
EvAClient.this,
Main.this,
"Do you really want to exit EvA2?",
"Exit Application",
JOptionPane.YES_NO_OPTION);
if (result == JOptionPane.YES_OPTION) {
EvAClient.this.close();
Main.this.close();
}
}
});
@@ -572,7 +561,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
* The one and only main of the client program. Possible arguments:
* --autorun immediately starts the optimization (with parameters loaded
* from current directory if available. --hostname HOST: sets the hostname
* for the EvAClient to HOST --nosplash: skip the splash screen. --params
* for the Main to HOST --nosplash: skip the splash screen. --params
* PFILE: load the optimization parameter from the serialized file PFILE
*
* @param args command line parameters
@@ -630,7 +619,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
String hostName = StringTools.checkSingleStringArg(keys[4], values[4], arities[4] - 1);
String paramsFile = StringTools.checkSingleStringArg(keys[5], values[5], arities[5] - 1);
new EvAClient(hostName, paramsFile, autorun, nosplash, nogui, treeView);
new Main(hostName, paramsFile, autorun, nosplash, nogui, treeView);
}
}
@@ -643,12 +632,12 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
* optimization
* @param windowListener additional window listener for client frame
*/
public static EvAClient initClientGUI(OptimizationParameters goParams,
public static Main initClientGUI(OptimizationParameters goParams,
InterfaceStatisticsListener statisticsListener,
WindowListener windowListener, final Window parent) {
EvAClient evaClient;
Main evaClient;
evaClient = new EvAClient(null, parent, null, goParams,
evaClient = new Main(null, parent, null, goParams,
false, true, false, false); // initializes GUI in the background
// important: wait for GUI initialization before accessing any internal
// settings:
@@ -724,7 +713,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
@Override
public void actionPerformed(final ActionEvent event) {
EvAClient.this.close();
Main.this.close();
}
};
@@ -744,7 +733,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
public void actionPerformed(final ActionEvent event) {
// ToDo
String helpHS = "EvA2Help/EvA2Help.hs";
ClassLoader cl = EvAClient.class.getClassLoader();
ClassLoader cl = Main.class.getClassLoader();
JHelpContentViewer helpPane;
try {
URL hsURL = HelpSet.findHelpSet(cl, helpHS);
@@ -942,7 +931,7 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
* Create a tree view of an object based on EvATreeNode. It is encapsulated
* in a JScrollPane.
*
* @see EvATreeNode
* @see eva2.gui.EvATreeNode
* @param title
* @param object
* @return
@@ -1036,35 +1025,3 @@ public class EvAClient extends JFrame implements OptimizationStateListener {
}
}
}
final class SplashScreen extends Frame {
private static final long serialVersionUID = 1281793825850423095L;
private String imgLocation;
public SplashScreen(String imgLoc) {
imgLocation = imgLoc;
}
/**
* Show the splash screen to the end user.
*
* <P>Once this method returns, the splash screen is realized, which means
* that almost all work on the splash screen should proceed through the
* event dispatch thread. In particular, any call to
* <code>dispose</code> for the splash screen must be performed in the event
* dispatch thread.
*/
public void splash() {
JWindow splashWindow = new JWindow(this);
BasicResourceLoader loader = BasicResourceLoader.instance();
byte[] bytes = loader.getBytesFromResourceLocation(imgLocation, true);
ImageIcon ii = new ImageIcon(Toolkit.getDefaultToolkit().createImage(bytes));
JLabel splashLabel = new JLabel(ii);
splashWindow.add(splashLabel);
splashWindow.pack();
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
splashWindow.setLocation(screenSize.width / 2 - splashWindow.getSize().width / 2, screenSize.height / 2 - splashWindow.getSize().height / 2);
splashWindow.setVisible(true);
}
}

51
src/eva2/gui/SplashScreen.java Normal file
View File

@@ -0,0 +1,51 @@
package eva2.gui;
/*
* Title: EvA2
* Description: The main client class of the EvA framework.
* Copyright: Copyright (c) 2008
* Company: University of Tuebingen, Computer
* Architecture
*
* @author Holger Ulmer, Felix Streichert, Hannes Planatscher
* @version: $Revision: 322 $ $Date: 2007-12-11 17:24:07 +0100 (Tue, 11 Dec 2007)$
* $Author: mkron $
*/
import eva2.tools.BasicResourceLoader;
import java.awt.*;
import javax.swing.*;
class SplashScreen extends Frame {
private static final long serialVersionUID = 1281793825850423095L;
private String imgLocation;
public SplashScreen(String imgLoc) {
imgLocation = imgLoc;
}
/**
* Show the splash screen to the end user.
*
* <P>Once this method returns, the splash screen is realized, which means
* that almost all work on the splash screen should proceed through the
* event dispatch thread. In particular, any call to
* <code>dispose</code> for the splash screen must be performed in the event
* dispatch thread.
*/
public void splash() {
JWindow splashWindow = new JWindow(this);
BasicResourceLoader loader = BasicResourceLoader.instance();
byte[] bytes = loader.getBytesFromResourceLocation(imgLocation, true);
ImageIcon ii = new ImageIcon(Toolkit.getDefaultToolkit().createImage(bytes));
JLabel splashLabel = new JLabel(ii);
splashWindow.add(splashLabel);
splashWindow.pack();
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
splashWindow.setLocation(screenSize.width / 2 - splashWindow.getSize().width / 2, screenSize.height / 2 - splashWindow.getSize().height / 2);
splashWindow.setVisible(true);
}
}

2
src/eva2/optimization/go/GOStandaloneVersion.java
View File

@@ -166,7 +166,7 @@ public class GOStandaloneVersion implements InterfaceGOStandalone, InterfacePopu
}
this.m_O1 = (paraPanel.makePanel());
// TODO this is defunct anyways... (MK, 2010-03)
// EvAClient.setProperty("eva2.server.oa.go.Tools.InterfaceTest", "eva2.server.oa.go.Tools.Test1,eva2.server.oa.go.Tools.Test2");
// Main.setProperty("eva2.server.oa.go.Tools.InterfaceTest", "eva2.server.oa.go.Tools.Test1,eva2.server.oa.go.Tools.Test2");
this.m_OptionsPanel = new JTabbedPane();
JParaPanel paraPanel2 = new JParaPanel(this.m_GO, "MyGUI");
this.m_O2 = (paraPanel2.makePanel());

19
src/eva2/optimization/operator/archiving/ArchivingNSGAII.java
View File

@@ -39,25 +39,6 @@ public class ArchivingNSGAII extends ArchivingNSGA implements java.io.Serializab
pop.SetArchive(new Population());
}
//////////////////////////////////////////////////////////////////////////////////////////////
if (this.m_Debug && false) {
// plot the complete population
double[] tmpD = new double[2];
tmpD[0] = 0;
tmpD[1] = 0;
this.m_Plot = new eva2.gui.Plot("Debug NSGAII", "Y1", "Y2", tmpD, tmpD);
System.out.println("Population size: " + pop.size());
// plot the population
this.m_Plot.setUnconnectedPoint(0, 0, 11);
this.m_Plot.setUnconnectedPoint(1.05, 2.5, 11);
double[][] trueFitness = new double[pop.size()][];
for (int i = 0; i < pop.size(); i++) {
trueFitness[i] = ((AbstractEAIndividual)pop.get(i)).getFitness();
this.m_Plot.setUnconnectedPoint(trueFitness[i][0], trueFitness[i][1], 11);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
// First merge the current population and the archive
Population tmpPop = new Population();
tmpPop.addPopulation((Population)pop.getClone());

101
src/eva2/optimization/operator/archiving/ArchivingPESAII.java
View File

@@ -48,36 +48,6 @@ public class ArchivingPESAII extends AbstractArchiving implements java.io.Serial
}
Population archive = pop.getArchive();
////////////////////////////////////////////////////////////////////////////////////
if (this.m_Debug) {
this.m_Plot = new eva2.gui.Plot("Debug SPEAII", "Y1", "Y2", true);
System.out.println("Population size: " + pop.size());
// plot the population
this.m_Plot.setUnconnectedPoint(0, 0, 11);
this.m_Plot.setUnconnectedPoint(1.2, 2.0, 11);
Population tmpPop = new Population();
tmpPop.addPopulation(pop);
tmpPop.addPopulation(pop.getArchive());
double[][] trueFitness;
GraphPointSet mySet = new GraphPointSet(10, this.m_Plot.getFunctionArea());
DPoint myPoint;
Chart2DDPointIconText tmp;
trueFitness = new double[archive.size()][];
for (int i = 0; i < archive.size(); i++) {
trueFitness[i] = ((AbstractEAIndividual)archive.get(i)).getFitness();
}
mySet.setConnectedMode(false);
for (int i = 0; i < trueFitness.length; i++) {
myPoint = new DPoint(trueFitness[i][0], trueFitness[i][1]);
tmp = new Chart2DDPointIconText("");
tmp.setIcon(new Chart2DDPointIconCircle());
myPoint.setIcon(tmp);
mySet.addDPoint(myPoint);
}
}
////////////////////////////////////////////////////////////////////////////////////
// test for each element in population if it
// is dominating a element in the archive
for (int i = 0; i < pop.size(); i++) {
@@ -87,57 +57,7 @@ public class ArchivingPESAII extends AbstractArchiving implements java.io.Serial
}
////////////////////////////////////////////////////////////////////////////////////
if (this.m_Debug) {
// first plot the grid
double[][] bounds;
double[][] trueFitness = new double[archive.size()][];
// first calculate the bounds of the search space
bounds = new double[((AbstractEAIndividual)archive.get(0)).getFitness().length][2];
for (int i = 0; i < bounds.length; i++) {
bounds[i][0] = Double.POSITIVE_INFINITY;
bounds[i][1] = Double.NEGATIVE_INFINITY;
}
for (int i = 0; i < archive.size(); i++) {
trueFitness[i] = ((AbstractEAIndividual)archive.get(i)).getFitness();
for (int j = 0; j < trueFitness[i].length; j++) {
if (trueFitness[i][j] < bounds[j][0]) {
bounds[j][0] = trueFitness[i][j];
}
if (trueFitness[i][j] > bounds[j][1]) {
bounds[j][1] = trueFitness[i][j];
}
}
}
double gridx, gridy;
DLine line;
gridx = (bounds[0][1] - bounds[0][0])/this.m_GridSize;
gridy = (bounds[1][1] - bounds[1][0])/this.m_GridSize;
for (int i = 0; i <= this.m_GridSize; i++) {
line = new DLine(bounds[0][0]+gridx*i, bounds[1][0], bounds[0][0]+gridx*i, bounds[1][1], Color.BLUE);
this.m_Plot.getFunctionArea().addDElement(line);
line = new DLine(bounds[0][0], bounds[1][0]+gridy*i, bounds[0][1], bounds[1][0]+gridy*i, Color.BLUE);
this.m_Plot.getFunctionArea().addDElement(line);
}
// now plot the archive with squeezing factor
int[] sqFactor = this.calculateSqueezeFactor(archive);
GraphPointSet mySet = new GraphPointSet(10, this.m_Plot.getFunctionArea());
DPoint myPoint;
Chart2DDPointIconText tmp;
Chart2DDPointIconCircle tmp2;
mySet.setConnectedMode(false);
for (int i = 0; i < trueFitness.length; i++) {
myPoint = new DPoint(trueFitness[i][0], trueFitness[i][1]);
tmp = new Chart2DDPointIconText("SF:"+sqFactor[i]);
tmp2 = new Chart2DDPointIconCircle();
tmp2.setFillColor(Color.GREEN);
tmp.setIcon(tmp2);
myPoint.setIcon(tmp);
mySet.addDPoint(myPoint);
}
}
////////////////////////////////////////////////////////////////////////////////////
// Now check whether there are individuals to remove
int bigSqueeze, index;
@@ -157,27 +77,6 @@ public class ArchivingPESAII extends AbstractArchiving implements java.io.Serial
}
archive.remove(index);
}
////////////////////////////////////////////////////////////////////////////////////
if (this.m_Debug) {
double[][] trueFitness;
GraphPointSet mySet = new GraphPointSet(10, this.m_Plot.getFunctionArea());
DPoint myPoint;
Chart2DDPointIconCircle tmp;
trueFitness = new double[archive.size()][];
for (int i = 0; i < archive.size(); i++) {
trueFitness[i] = ((AbstractEAIndividual)archive.get(i)).getFitness();
}
mySet.setConnectedMode(false);
for (int i = 0; i < trueFitness.length; i++) {
myPoint = new DPoint(trueFitness[i][0], trueFitness[i][1]);
tmp = new Chart2DDPointIconCircle();
tmp.setFillColor(Color.RED);
myPoint.setIcon(tmp);
mySet.addDPoint(myPoint);
}
}
////////////////////////////////////////////////////////////////////////////////////
}
/** This method will calculate the squeeze factor for a population

186
src/eva2/optimization/operator/archiving/ArchivingSPEAII.java
View File

@@ -48,16 +48,6 @@ public class ArchivingSPEAII extends AbstractArchiving implements java.io.Serial
pop.SetArchive(new Population());
}
////////////////////////////////////////////////////////////////////////////////////
if (this.m_Debug) {
this.m_Plot = new eva2.gui.Plot("Debug SPEAII", "Y1", "Y2", true);
System.out.println("Population size: " + pop.size());
// plot the population
this.m_Plot.setUnconnectedPoint(0, 0, 11);
this.m_Plot.setUnconnectedPoint(1.2, 2.0, 11);
}
////////////////////////////////////////////////////////////////////////////////////
// First merge the current population and the archive
Population tmpPop = new Population();
tmpPop.addPopulation((Population)pop.getClone());
@@ -73,30 +63,6 @@ public class ArchivingSPEAII extends AbstractArchiving implements java.io.Serial
// ((AbstractEAIndividual)tmpPop.get(i)).SetData("kthDistance", new Double(kthDistance[i]));
// }
////////////////////////////////////////////////////////////////////////////////////
if (this.m_Debug) {
double[][] trueFitness;
GraphPointSet mySet = new GraphPointSet(10, this.m_Plot.getFunctionArea());
DPoint myPoint;
double tmp1, tmp2;
Chart2DDPointIconText tmp;
trueFitness = new double[tmpPop.size()][];
for (int i = 0; i < tmpPop.size(); i++) {
trueFitness[i] = ((AbstractEAIndividual)tmpPop.get(i)).getFitness();
}
mySet.setConnectedMode(false);
for (int i = 0; i < trueFitness.length; i++) {
myPoint = new DPoint(trueFitness[i][0], trueFitness[i][1]);
tmp1 = Math.round(RawFitness[i]*100)/(double)100;
tmp2 = Math.round(kthDistance[i]*100)/(double)100;
tmp = new Chart2DDPointIconText("RF:"+RawFitness[i]+"/ KD:"+tmp2);
tmp.setIcon(new Chart2DDPointIconCircle());
myPoint.setIcon(tmp);
mySet.addDPoint(myPoint);
}
}
////////////////////////////////////////////////////////////////////////////////////
// Now init the new archive
Population archive = new Population();
archive.setTargetSize(pop.getArchive().getTargetSize());
@@ -110,54 +76,6 @@ public class ArchivingSPEAII extends AbstractArchiving implements java.io.Serial
archive.add(tmpPop.get(i));
}
}
///////////////////////////////////////////////////////////////////////////////
// double[][] p = this.showMay(archive);
// if ((true) && ((p[0][0] > d[0][0]) || (p[1][1] > d[1][1]))) {
// this.tz = true;
// this.calculateRawFitness(tmpPop);
// this.tz = false;
// this.m_Plot = new eva2.gui.Plot("Debug SPEAII", "Y1", "Y2");
// // plot the population
// this.m_Plot.setUnconnectedPoint(0, 0, 11);
// this.m_Plot.setUnconnectedPoint(1.2, 2.0, 11);
// System.out.println("------------------Alert max!");
// double[][] trueFitness;
// GraphPointSet mySet = new GraphPointSet(10, this.m_Plot.getFunctionArea());
// DPoint myPoint;
// double tmp1, tmp2;
// Chart2DDPointIconText tmp;
// trueFitness = new double[tmpPop.size()][];
// for (int i = 0; i < tmpPop.size(); i++) {
// trueFitness[i] = ((AbstractEAIndividual)tmpPop.get(i)).getFitness();
// }
// mySet.setConnectedMode(false);
// for (int i = 0; i < trueFitness.length; i++) {
// myPoint = new DPoint(trueFitness[i][0], trueFitness[i][1]);
// tmp1 = Math.round(RawFitness[i]*100)/(double)100;
// tmp2 = Math.round(kthDistance[i]*100)/(double)100;
// tmp = new Chart2DDPointIconText(""+RawFitness[i]+"/"+tmp2);
// tmp.setIcon(new Chart2DDPointIconCircle());
// myPoint.setIcon(tmp);
// mySet.addDPoint(myPoint);
// }
//
// mySet = new GraphPointSet(10, this.m_Plot.getFunctionArea());
// Chart2DDPointIconCircle tmpC;
// trueFitness = new double[archive.size()][];
// for (int i = 0; i < archive.size(); i++) {
// trueFitness[i] = ((AbstractEAIndividual)archive.get(i)).getFitness();
// }
// mySet.setConnectedMode(false);
// for (int i = 0; i < trueFitness.length; i++) {
// myPoint = new DPoint(trueFitness[i][0], trueFitness[i][1]);
// tmpC = new Chart2DDPointIconCircle();
// tmpC.setFillColor(Color.GREEN);
// myPoint.setIcon(tmpC);
// mySet.addDPoint(myPoint);
// }
// }
/////////////////////////////////////////////////////////////////////////////////////
// if there is some place left let's add some more
int currentLevel = 0;
@@ -169,26 +87,6 @@ public class ArchivingSPEAII extends AbstractArchiving implements java.io.Serial
}
}
}
////////////////////////////////////////////////////////////////////////////////////
if (this.m_Debug) {
double[][] trueFitness;
GraphPointSet mySet = new GraphPointSet(10, this.m_Plot.getFunctionArea());
DPoint myPoint;
Chart2DDPointIconCircle tmp;
trueFitness = new double[archive.size()][];
for (int i = 0; i < archive.size(); i++) {
trueFitness[i] = ((AbstractEAIndividual)archive.get(i)).getFitness();
}
mySet.setConnectedMode(false);
for (int i = 0; i < trueFitness.length; i++) {
myPoint = new DPoint(trueFitness[i][0], trueFitness[i][1]);
tmp = new Chart2DDPointIconCircle();
tmp.setFillColor(Color.GREEN);
myPoint.setIcon(tmp);
mySet.addDPoint(myPoint);
}
}
////////////////////////////////////////////////////////////////////////////////////
// Here i want to remove surplus individuals *pff*
// So the basic idea is to search on the highes level of
@@ -215,72 +113,8 @@ public class ArchivingSPEAII extends AbstractArchiving implements java.io.Serial
archive.remove(ICurSma);
}
////////////////////////////////////////////////////////////////////////////////////
if (this.m_Debug) {
double[][] trueFitness;
GraphPointSet mySet = new GraphPointSet(10, this.m_Plot.getFunctionArea());
DPoint myPoint;
Chart2DDPointIconCircle tmp;
trueFitness = new double[archive.size()][];
for (int i = 0; i < archive.size(); i++) {
trueFitness[i] = ((AbstractEAIndividual)archive.get(i)).getFitness();
}
mySet.setConnectedMode(false);
for (int i = 0; i < trueFitness.length; i++) {
myPoint = new DPoint(trueFitness[i][0], trueFitness[i][1]);
tmp = new Chart2DDPointIconCircle();
tmp.setFillColor(Color.RED);
myPoint.setIcon(tmp);
mySet.addDPoint(myPoint);
}
}
////////////////////////////////////////////////////////////////////////////////////
pop.SetArchive(archive);
// if there are too many let's remove the surplus
// i could simply remove the individuals with the
// smallest distance to a neighbor selecting from
// all individuals or just selecting from the ones
// in the range of currentLevel to currentLevel+1
// while (archive.size() > archive.getPopulationSize()) {
// // now it's time to use the <=d operator e.g.
// // remove the individuals that are to close
// // to thier neighbours
// double[][] dist
//
// }
//
// // might sound stuid but as far as i understood this
// // i'll simply select the n best ones regarding SPEAFit
// Population archive = (Population)pop.getArchive().clone();
// archive.clear();
// double smallest;
// int index;
// for (int i = 0; i < archive.getPopulationSize(); i++) {
// // find the smallest one
// index = -1;
// smallest = Double.POSITIVE_INFINITY;
// for (int j = 0; j < SPEAFit.length; j++) {
// if (smallest > SPEAFit[j]) {
// smallest = SPEAFit[j];
// index = j;
// }
// }
//
// if (index > -1) {
// SPEAFit[index] = Double.POSITIVE_INFINITY;
// archive.add(tmpPop.get(index));
// }
// }
// if (this.m_Debug) {
// // plot the archive
// double[] tmpD;
// for (int i = 0; i < archive.size(); i++) {
// tmpD = ((AbstractEAIndividual)archive.get(i)).getFitness();
// this.m_Plot.setUnconnectedPoint(tmpD[0], tmpD[1], 12);
// }
// }
}
private double[][] showMay(Population pop) {
@@ -539,26 +373,6 @@ public class ArchivingSPEAII extends AbstractArchiving implements java.io.Serial
((AbstractEAIndividual)pop.get(i)).putData("SPEAFit", new Double(SPEAResult[i]));
}
if (this.m_Debug && this.m_Plot != null) {
//System.out.println("k: " + k);
GraphPointSet mySet = new GraphPointSet(10, this.m_Plot.getFunctionArea());
DPoint myPoint;
double tmp1, tmp2;
Chart2DDPointIconText tmp;
mySet.setConnectedMode(false);
for (int i = 0; i < trueFitness.length; i++) {
myPoint = new DPoint(trueFitness[i][0], trueFitness[i][1]);
tmp1 = Math.round(SPEAResult[i]*100)/(double)100;
tmp2 = Math.round(D[i]*100)/(double)100;
tmp = new Chart2DDPointIconText(""+SPEAStrength[i]+"/"+SPEAFitness[i]);
tmp.setIcon(new Chart2DDPointIconCircle());
myPoint.setIcon(tmp);
mySet.addDPoint(myPoint);
}
}
// Puh!
return SPEAResult;
}

4
src/eva2/optimization/problems/ERPStarter.java
View File

@@ -2,7 +2,7 @@ package eva2.optimization.problems;
import eva2.OptimizerFactory;
import eva2.OptimizerRunnable;
import eva2.client.EvAClient;
import eva2.gui.Main;
import eva2.gui.BeanInspector;
import eva2.optimization.individuals.AbstractEAIndividual;
import eva2.optimization.modules.OptimizationParameters;
@@ -85,7 +85,7 @@ public class ERPStarter {
// Instantiate optimization
OptimizationParameters params = new OptimizationParameters(opt, erp, new EvaluationTerminator(maxEvals));
if (startGUI) {
EvAClient.initClientGUI(params, null, null, null);
Main.initClientGUI(params, null, null, null);
} else {
OptimizerRunnable rnbl = new OptimizerRunnable(params, new StatisticsStandalone(outputFilePrefix, 1, 3, true), false);
// actually start the optimization

388
src/eva2/optimization/stat/AbstractStatistics.java
View File

@@ -13,6 +13,7 @@ import eva2.tools.StringSelection;
import eva2.tools.StringTools;
import eva2.tools.ToolBox;
import eva2.tools.math.Mathematics;
import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintWriter;
@@ -25,27 +26,25 @@ import java.util.*;
* updated per iteration in createNextGenerationPerformed and reported to listeners in stopOptPerformed.
* Several different verbosity levels are regarded.
* The method plotCurrentResults should be implemented to plot further results per iteration.
*
* <p/>
* All displayable data is now routed through a single pipeline, which consists in a
* list of Objects assembled in the getOutputValues method. This allows all simple data types which are
* provided by the external informer instances to be handled uniformly to the internally collected data, and
* thus they can be plotted and text-dumped in the same manner.
* Basic fields are identified by the enum GraphSelectionEnum and are available independently of additional
* informer instances.
*
* <p/>
* Depending on the field selection state and the informers, the list of data fields is dynamically altered,
* however changes during a multi-run are ignored, since the potential of inconsistencies is too high.
*
* <p/>
* Listeners implementing InterfaceTextListener receive String output (human readable).
* Listeners implementing InterfaceStatisticsListener receive the raw data per iteration.
*
* @see StatsParameter
* @author mkron
*
* @see StatsParameter
*/
public abstract class AbstractStatistics implements InterfaceTextListener, InterfaceStatistics {
private transient PrintWriter resultOut;
public final static boolean TRACE = false;
protected InterfaceStatisticsParameter m_StatsParams;
/**
@@ -57,7 +56,7 @@ public abstract class AbstractStatistics implements InterfaceTextListener, Inter
* by dynamic population optimizers, also due to the graph output.
*/
private boolean refineMultiRuns = true;
// private ArrayList<double[][]> meanCollection;
// private ArrayList<double[][]> meanCollection;
private ArrayList<Object[]> finalObjectData;
private ArrayList<Double[]> sumDataCollection; // collect summed-up data of multiple runs indexed per iteration
protected Object[] currentStatObjectData = null; // the raw Object data collected in an iteration
@@ -84,10 +83,10 @@ public abstract class AbstractStatistics implements InterfaceTextListener, Inter
protected int optRunsPerformed;
protected double[] currentBestFit;
protected double[] currentBestFeasibleFit;
// protected double[] meanBestFeasibleFit;
// protected double[] meanBestFeasibleFit;
protected double[] currentMeanFit;
protected double[] currentWorstFit;
// protected double[] meanBestOfRunFitness;
// protected double[] meanBestOfRunFitness;
protected double currentAvgEucDistInPop, currentMaxEucDistInPop;
protected double currentAvgPopDistMetric, currentMaxPopDistMetric;
protected IndividualInterface bestCurrentIndy, bestOfRunIndy, bestOfRunFeasibleIndy, bestFeasibleAllRuns, bestIndyAllRuns;
@@ -119,33 +118,33 @@ public abstract class AbstractStatistics implements InterfaceTextListener, Inter
@Override
public void addDataListener(InterfaceStatisticsListener l) {
if (dataListeners==null) {
dataListeners=new LinkedList<InterfaceStatisticsListener>();
if (dataListeners == null) {
dataListeners = new LinkedList<InterfaceStatisticsListener>();
}
if (l!=null && !dataListeners.contains(l)) {
if (l != null && !dataListeners.contains(l)) {
dataListeners.add(l);
}
}
@Override
public boolean removeDataListener(InterfaceStatisticsListener l) {
if (dataListeners==null) {
if (dataListeners == null) {
return false;
}
else {
} else {
return dataListeners.remove(l);
}
}
private void fireDataListeners() {
if (dataListeners!=null) {
if (dataListeners != null) {
for (InterfaceStatisticsListener l : dataListeners) {
l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentStatDoubleData);
} }
l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentStatDoubleData);
}
}
}
private void fireDataListenersFinalize() {
if (dataListeners!=null) {
if (dataListeners != null) {
LinkedList<InterfaceStatisticsListener> toRemove = new LinkedList<InterfaceStatisticsListener>();
for (InterfaceStatisticsListener l : dataListeners) {
boolean rm = l.notifyMultiRunFinished(currentStatHeader, finalObjectData);
@@ -167,7 +166,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
* @param start if true, give the start signal, otherwise the stop signal
*/
private void fireDataListenersStartStop(int runNumber, boolean normal, boolean start) {
if (dataListeners!=null) {
if (dataListeners != null) {
for (InterfaceStatisticsListener l : dataListeners) {
if (start) {
l.notifyRunStarted(runNumber, m_StatsParams.getMultiRuns(),
@@ -178,8 +177,9 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
l.finalMultiRunResults(currentStatHeader,
finalObjectData);
// }
}
} }
}
}
}
}
@Override
@@ -206,14 +206,11 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
&& (m_StatsParams.getOutputVerbosity().getSelectedTagID() > StatisticsParameter.VERBOSITY_NONE)) { // verbosity accordingly high
//!resFName.equalsIgnoreCase("none") && !resFName.equals("")) {
String fnameBase = makeOutputFileName(m_StatsParams.getResultFilePrefix(), infoString, startDate);
int cnt=0;
int cnt = 0;
String fname = fnameBase;
while (new File(fname).exists()) {
cnt++;
fname=fnameBase+"."+cnt;
}
if (TRACE) {
System.out.println("FileName =" + fname);
fname = fnameBase + "." + cnt;
}
try {
resultOut = new PrintWriter(new FileOutputStream(fname));
@@ -230,6 +227,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
/**
* Return a simple String describing the current date and time.
*
* @return
*/
public static String getDateString() {
@@ -239,12 +237,13 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
}
protected boolean doFileOutput() {
return (m_StatsParams.getOutputTo().getSelectedTagID()!=1); // not "text-window only"
return (m_StatsParams.getOutputTo().getSelectedTagID() != 1); // not "text-window only"
}
private String makeOutputFileName(String prefix, String infoString, String startDate) {
return (prefix + "_" + infoString).replace(' ', '_') + "_" + startDate + ".txt";
}
/**
* If set to true, before every run the parameters will be stored to a file at the start
* of each run. Default is true.
@@ -257,20 +256,16 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
@Override
public void startOptPerformed(String infoString, int runNumber, Object params, List<InterfaceAdditionalPopulationInformer> informerList) {
if (TRACE) {
System.out.println("AbstractStatistics.startOptPerformed " + runNumber);
System.out.println("Statsparams were " + BeanInspector.toString(m_StatsParams));
}
if (runNumber == 0) {
// store the intial graph selection state, so that modifications during runtime cannot cause inconsistencies
lastFieldSelection = (StringSelection)m_StatsParams.getFieldSelection().clone();
lastFieldSelection = (StringSelection) m_StatsParams.getFieldSelection().clone();
lastIsShowFull = m_StatsParams.isOutputAllFieldsAsText();
currentStatDoubleData=null;
currentStatObjectData=null;
currentStatDoubleData = null;
currentStatObjectData = null;
List<String> headerFields=getOutputHeaderFieldNames(informerList);
List<String> headerFields = getOutputHeaderFieldNames(informerList);
currentStatHeader = headerFields.toArray(new String[headerFields.size()]);
currentStatMetaInfo = getOutputMetaInfoAsArray(informerList);
@@ -292,8 +287,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
// else meanCollection = null;
if (refineMultiRuns) {
sumDataCollection = new ArrayList<Double[]>();
}
else {
} else {
sumDataCollection = null;
}
@@ -301,20 +295,20 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
statDataSumOverAll = null;
// lastAdditionalInfoSums = null;
feasibleFoundAfterSum=-1;
numOfRunsFeasibleFound=0;
feasibleFoundAfterSum = -1;
numOfRunsFeasibleFound = 0;
}
feasibleFoundAfter=-1;
feasibleFoundAfter = -1;
bestCurrentIndy = null;
bestOfRunIndy = null;
currentBestFeasibleFit=null;
currentBestFeasibleFit = null;
bestOfRunFeasibleIndy = null;
lastInformerList = null;
lastSols = null;
iterationCounter = 0;
if (printRunIntroVerbosity()) {
printToTextListener("\n****** Multirun "+runNumber);
printToTextListener("\n****** Multirun " + runNumber);
}
if (params != null) {
if (printRunIntroVerbosity()) {
@@ -336,19 +330,13 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
@Override
public void stopOptPerformed(boolean normal, String stopMessage) {
if (TRACE) {
System.out.println("AbstractStatistics.stopOptPerformed");
}
if (lastSols==null) {
if (lastSols == null) {
System.err.println("WARNING, possibly there was no call to createNextGenerationPerformed before calling stopOptPerformed (AnstractStatistics).");
}
if (iterationCounter < sumDataCollection.size()) {
// no good: later run was shorter than the first one. What to do? Discard the longer one:
if (TRACE) {
System.err.println("Error in AbstractStatistics: later run was shorter than earlier one... discarding rest...");
}
for (int i=sumDataCollection.size()-1; i>=iterationCounter; i--) {
for (int i = sumDataCollection.size() - 1; i >= iterationCounter; i--) {
sumDataCollection.remove(i);
}
}
@@ -378,7 +366,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
// meanBestOfRunFitness=bestRunIndividual.getFitness().clone();
// } else addSecond(meanBestOfRunFitness, bestRunIndividual.getFitness());
}
if (feasibleFoundAfter>0) {
if (feasibleFoundAfter > 0) {
if (printRunStoppedVerbosity()) {
printToTextListener(" Feasible ind. found after " + feasibleFoundAfter + " evaluations.\n");
}
@@ -388,7 +376,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
}
}
if (printRunStoppedVerbosity()) {
printToTextListener(" Solution correlations (min,max,avg,med,var): " + BeanInspector.toString(((Population)lastSols).getCorrelations((Population)lastSols)) + "\n");
printToTextListener(" Solution correlations (min,max,avg,med,var): " + BeanInspector.toString(((Population) lastSols).getCorrelations((Population) lastSols)) + "\n");
}
if (bestOfRunFeasibleIndy != null) {
runBestFeasibleList.add(bestOfRunFeasibleIndy);
@@ -396,14 +384,14 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
// meanBestFeasibleFit=bestRunFeasibleIndy.getFitness().clone();
// } else addSecond(meanBestFeasibleFit, bestRunFeasibleIndy.getFitness());
if (printRunStoppedVerbosity()) {
if ((bestOfRunFeasibleIndy instanceof AbstractEAIndividual) && ((AbstractEAIndividual)bestOfRunFeasibleIndy).equalGenotypes((AbstractEAIndividual)bestOfRunIndy)) {
if ((bestOfRunFeasibleIndy instanceof AbstractEAIndividual) && ((AbstractEAIndividual) bestOfRunFeasibleIndy).equalGenotypes((AbstractEAIndividual) bestOfRunIndy)) {
printToTextListener("* Run best feasible individual equals best individual.\n");
} else {
if (bestOfRunIndy instanceof AbstractEAIndividual) {
if (((AbstractEAIndividual)bestOfRunIndy).violatesConstraint()) {
printToTextListener(" Run best individual violates constraints by " + ((AbstractEAIndividual)bestOfRunIndy).getConstraintViolation() + "\n");
if (((AbstractEAIndividual) bestOfRunIndy).violatesConstraint()) {
printToTextListener(" Run best individual violates constraints by " + ((AbstractEAIndividual) bestOfRunIndy).getConstraintViolation() + "\n");
}
if (((AbstractEAIndividual)bestOfRunIndy).isMarkedPenalized()) {
if (((AbstractEAIndividual) bestOfRunIndy).isMarkedPenalized()) {
printToTextListener(" Run best individual is penalized.\n");
}
}
@@ -411,7 +399,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
}
}
}
if (finalObjectData==null) {
if (finalObjectData == null) {
finalObjectData = new ArrayList<Object[]>();
}
finalObjectData.add(currentStatObjectData);
@@ -431,9 +419,9 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
printToTextListener("\n");
}
if (printRunStoppedVerbosity()) {
if (resultPop!=null && (resultPop.size()>0)) {
if (resultPop != null && (resultPop.size() > 0)) {
printToTextListener("Resulting population: \n");
for (int i=0; i<resultPop.size(); i++) {
for (int i = 0; i < resultPop.size(); i++) {
printToTextListener(AbstractEAIndividual.getDefaultStringRepresentation(resultPop.getEAIndividual(i)));
printToTextListener("\n");
}
@@ -451,7 +439,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
// if (bestCurrentIndy!=null) pop.add(bestCurrentIndy);
// if (bestOfRunIndy!=null) pop.add(bestOfRunIndy);
// if (bestOfRunFeasibleIndy!=null) pop.add(bestOfRunFeasibleIndy);
if (bestIndyAllRuns!=null) {
if (bestIndyAllRuns != null) {
pop.add(bestIndyAllRuns);
}
return pop;
@@ -463,12 +451,10 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
printToTextListener(" solution fit : " + BeanInspector.toString(indy.getFitness()));
if (!(indy instanceof AbstractEAIndividual)) {
printToTextListener(" - feasibility unknown\n");
}
else {
if (((AbstractEAIndividual)indy).isMarkedPenalized() || ((AbstractEAIndividual)indy).violatesConstraint()) {
} else {
if (((AbstractEAIndividual) indy).isMarkedPenalized() || ((AbstractEAIndividual) indy).violatesConstraint()) {
printToTextListener(" - infeasible\n");
}
else {
} else {
printToTextListener("\n");
}
}
@@ -495,29 +481,29 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
protected void finalizeOutput() {
if (printFinalVerbosity()) {
printToTextListener("*******\n Runs performed: " + optRunsPerformed + ", reached target " + convergenceCnt + " times with threshold " + m_StatsParams.getConvergenceRateThreshold() + ", rate " + convergenceCnt/(double)m_StatsParams.getMultiRuns() + '\n');
printToTextListener("*******\n Runs performed: " + optRunsPerformed + ", reached target " + convergenceCnt + " times with threshold " + m_StatsParams.getConvergenceRateThreshold() + ", rate " + convergenceCnt / (double) m_StatsParams.getMultiRuns() + '\n');
}
if (printFinalVerbosity()) {
printToTextListener(" Average function calls: " + (functionCallSum/optRunsPerformed) + "\n");
printToTextListener(" Average function calls: " + (functionCallSum / optRunsPerformed) + "\n");
}
if (printFinalVerbosity() && (feasibleFoundAfterSum>=0.)) {
if (printFinalVerbosity() && (feasibleFoundAfterSum >= 0.)) {
printToTextListener(" Feasible solution found in " + numOfRunsFeasibleFound + " of " + optRunsPerformed + " runs \n");
printToTextListener(" Average evaluations until feasible ind. was found in " + numOfRunsFeasibleFound + " runs: " + feasibleFoundAfterSum/numOfRunsFeasibleFound + " evaluations\n");
printToTextListener(" Average evaluations until feasible ind. was found in " + numOfRunsFeasibleFound + " runs: " + feasibleFoundAfterSum / numOfRunsFeasibleFound + " evaluations\n");
}
if (printFinalVerbosity() && (statDataSumOverAll != null)) {
printToTextListener(" Averaged sum of run statistical data: (" + optRunsPerformed + " runs):");
for (int i=0; i<statDataSumOverAll.length; i++) {
if (statDataSumOverAll[i]!=null) {
printToTextListener(textFieldDelimiter+(statDataSumOverAll[i]/optRunsPerformed));
for (int i = 0; i < statDataSumOverAll.length; i++) {
if (statDataSumOverAll[i] != null) {
printToTextListener(textFieldDelimiter + (statDataSumOverAll[i] / optRunsPerformed));
}
}
printToTextListener("\n Averaged last statistical data (" + optRunsPerformed + " runs):");
Double[] lastSum = sumDataCollection.get(sumDataCollection.size()-1);
for (int i=0; i<lastSum.length; i++) {
if (lastSum[i]!=null) {
printToTextListener(textFieldDelimiter+(lastSum[i]/optRunsPerformed));
Double[] lastSum = sumDataCollection.get(sumDataCollection.size() - 1);
for (int i = 0; i < lastSum.length; i++) {
if (lastSum[i] != null) {
printToTextListener(textFieldDelimiter + (lastSum[i] / optRunsPerformed));
}
}
// for (int i=0; i<lastAdditionalInfoSums.length; i++) if (lastAdditionalInfoSums[i]!=null) printToTextListener(" \t"+(lastAdditionalInfoSums[i]/optRunsPerformed));
@@ -528,33 +514,33 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
printIndy("Overall best", bestIndyAllRuns);
}
if (printFinalVerbosity()) {
printToTextListener(getFinalAdditionalInfo()+'\n');
printToTextListener(getFinalAdditionalInfo() + '\n');
}
if (optRunsPerformed>1) {
if (runBestFitList.size()>0) {
if (optRunsPerformed > 1) {
if (runBestFitList.size() > 0) {
// Mathematics.svDiv((double)optRunsPerformed, meanBestOfRunFitness, meanBestOfRunFitness);
if (printFinalVerbosity()) {
double[] meanBestFit=getMeanBestFit(false);
printToTextListener(" MultiRun stats: Mean best fitness: " + BeanInspector.toString(meanBestFit)+"\n");
if (meanBestFit.length==1) {
double[] meanBestFit = getMeanBestFit(false);
printToTextListener(" MultiRun stats: Mean best fitness: " + BeanInspector.toString(meanBestFit) + "\n");
if (meanBestFit.length == 1) {
printToTextListener(" MultiRun stats: Variance/Std.Dev.: " + BeanInspector.toString(calcStdDevVar(runBestFitList, meanBestFit[0])) + "\n");
}
printToTextListener(" MultiRun stats: Median best fitn.: " + BeanInspector.toString(getMedianBestFit(false))+"\n");
printToTextListener(" MultiRun stats: Median best fitn.: " + BeanInspector.toString(getMedianBestFit(false)) + "\n");
}
}
if (printFinalVerbosity() && (bestFeasibleAllRuns != null)) {
printIndy("Overall best feasible", bestFeasibleAllRuns);
}
// if ((runBestFeasibleList.size()>0) && (!equalLists(runBestFeasibleList, runBestFitList))) { // is there a difference between best feasibles and best fit?
if (runBestFeasibleList.size()>0) { // always output feasible stats even if theyre equal
if (runBestFeasibleList.size() > 0) { // always output feasible stats even if theyre equal
if (printFinalVerbosity()) {
double[] meanBestFeasibleFit=getMeanBestFit(true);
printToTextListener(" MultiRun stats: Mean best feasible fitness (" + numOfRunsFeasibleFound + " runs): " + BeanInspector.toString(meanBestFeasibleFit)+"\n");
if (meanBestFeasibleFit.length==1) {
double[] meanBestFeasibleFit = getMeanBestFit(true);
printToTextListener(" MultiRun stats: Mean best feasible fitness (" + numOfRunsFeasibleFound + " runs): " + BeanInspector.toString(meanBestFeasibleFit) + "\n");
if (meanBestFeasibleFit.length == 1) {
printToTextListener(" MultiRun stats: Variance/Std.Dev.: " + BeanInspector.toString(calcStdDevVar(runBestFeasibleList, meanBestFeasibleFit[0])) + "\n");
}
printToTextListener(" MultiRun stats: Median best feasible fitn. (: " + numOfRunsFeasibleFound + " runs): " + BeanInspector.toString(getMedianBestFit(true))+"\n");
printToTextListener(" MultiRun stats: Median best feasible fitn. (: " + numOfRunsFeasibleFound + " runs): " + BeanInspector.toString(getMedianBestFit(true)) + "\n");
}
}
if (refineMultiRuns && (sumDataCollection != null)) {
@@ -562,25 +548,22 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
printToTextListener(" Averaged performance:\n");
}
// the summed-up values of the mean collection is divided by the number of runs
for (int i=0; i<sumDataCollection.size(); i++) {
for (int i = 0; i < sumDataCollection.size(); i++) {
divideMean(sumDataCollection.get(i), optRunsPerformed);
}
if (printFinalVerbosity()) {
printToTextListener(refineToText(sumDataCollection, showAvgIntervals));
}
}
if (printFinalVerbosity() && (finalObjectData!=null)) {
printToTextListener(" Last data line of " + finalObjectData.size() + " multi-runs:\n" );
for (int i=0; i<finalObjectData.size(); i++) {
if (printFinalVerbosity() && (finalObjectData != null)) {
printToTextListener(" Last data line of " + finalObjectData.size() + " multi-runs:\n");
for (int i = 0; i < finalObjectData.size(); i++) {
printToTextListener(BeanInspector.toString(finalObjectData.get(i)));
printToTextListener("\n");
}
}
}
if (TRACE) {
System.out.println("End of run");
}
if (resultOut != null) {
String StopDate = getDateString();
resultOut.println("StopDate:" + StopDate);
@@ -605,26 +588,27 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
}
private double[] calcStdDevVar(ArrayList<IndividualInterface> list, double meanFit) {
double tmp=0, sum=0;
for (Iterator<IndividualInterface> iter = list.iterator(); iter.hasNext();) {
double tmp = 0, sum = 0;
for (Iterator<IndividualInterface> iter = list.iterator(); iter.hasNext(); ) {
IndividualInterface indy = iter.next();
tmp=indy.getFitness()[0]-meanFit;
sum+=(tmp*tmp);
tmp = indy.getFitness()[0] - meanFit;
sum += (tmp * tmp);
}
double[] res = new double[2];
res[0]=sum/list.size();
res[1]=Math.sqrt(res[0]);
res[0] = sum / list.size();
res[1] = Math.sqrt(res[0]);
return res;
}
/**
* Calculate the mean fitness of a list of individuals.
*
* @param list
* @return
*/
public static double[] calcMeanFit(List<IndividualInterface> list) {
double[] sumFit = list.get(0).getFitness().clone();
for (int i=1; i<list.size(); i++) {
for (int i = 1; i < list.size(); i++) {
Mathematics.vvAdd(sumFit, list.get(i).getFitness(), sumFit);
}
Mathematics.svDiv(list.size(), sumFit, sumFit);
@@ -634,7 +618,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
public static double[] calcMedianFit(List<IndividualInterface> list) {
ArrayList<double[]> dblAList = new ArrayList<double[]>(list.size());
for (int i=0; i<list.size(); i++) {
for (int i = 0; i < list.size(); i++) {
dblAList.add(list.get(i).getFitness());
}
return Mathematics.median(dblAList, false);
@@ -651,17 +635,17 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
}
public static void refineToText(ArrayList<Double[]> data, int iterationsToShow, StringBuffer sbuf, String delim) {
double step = data.size()/(iterationsToShow-1.);
int printedIteration=0;
double step = data.size() / (iterationsToShow - 1.);
int printedIteration = 0;
Double[] meanData;
for(int i = 1; i < data.size()+1; i++) {
for (int i = 1; i < data.size() + 1; i++) {
// print the first, last and intermediate iterations requested by the integer parameter
// first one is printed always, as printedIteration=0
if ((i==data.size()) || ((i-1)==Math.round(printedIteration*step))) {
if ((i == data.size()) || ((i - 1) == Math.round(printedIteration * step))) {
printedIteration++;
meanData = data.get(i-1);
meanData = data.get(i - 1);
sbuf.append(i);
for (int k=0; k<meanData.length; k++) {
for (int k = 0; k < meanData.length; k++) {
sbuf.append(delim);
sbuf.append(BeanInspector.toString(meanData[k]));
}
@@ -714,6 +698,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
public void print(String str) {
printToTextListener(str);
}
////////////// InterfaceTextListener
@Override
public void println(String str) {
@@ -727,7 +712,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
}
protected boolean doTextOutput() {
return (resultOut != null) || (textListeners.size()>0);
return (resultOut != null) || (textListeners.size() > 0);
}
/**
@@ -781,7 +766,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
protected String[] getOutputMetaInfoAsArray(List<InterfaceAdditionalPopulationInformer> informerList) {
List<String> metaStrings = getOutputMetaInfo(informerList);
return metaStrings.toArray( new String[metaStrings.size()]);
return metaStrings.toArray(new String[metaStrings.size()]);
}
/**
@@ -789,15 +774,16 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
* method {@link #getSimpleOutputValues()}.
* Basic fields are identified by the enum GraphSelectionEnum and are available independently of additional
* informer instances.
* @see #getSimpleOutputValues()
*
* @return
* @see #getSimpleOutputValues()
*/
protected String[] getSimpleOutputHeader() {
// collect the full header by using the entries of the GraphSelectionEnum
GraphSelectionEnum[] vals = GraphSelectionEnum.values();
ArrayList<String>headerEntries = new ArrayList<String>();
ArrayList<String> headerEntries = new ArrayList<String>();
headerEntries.add("FunctionCalls");
for (int i=0; i<vals.length; i++) {
for (int i = 0; i < vals.length; i++) {
if (isRequestedField(vals[i])) {
headerEntries.add(vals[i].toString());
}
@@ -811,14 +797,14 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
* the method {@link #getSimpleOutputValues()}.
* Basic meta info is defined by the enum GraphSelectionEnum.
*
* @see #getSimpleOutputValues()
* @return
* @see #getSimpleOutputValues()
*/
protected String[] getSimpleOutputMetaInfo() {
GraphSelectionEnum[] vals = GraphSelectionEnum.values();
ArrayList<String> headerInfo = new ArrayList<String>();
headerInfo.add("The number of function evaluations");
for (int i=0; i<vals.length; i++) {
for (int i = 0; i < vals.length; i++) {
if (isRequestedField(vals[i])) {
headerInfo.add(GraphSelectionEnum.getInfoStrings()[i]);
}
@@ -864,28 +850,48 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
* Return all simple data fields collected internally. This must correspond to the
* method {@link #getSimpleOutputHeader()}.
*
* @see #getSimpleOutputHeader()
* @return
* @see #getSimpleOutputHeader()
*/
protected Object[] getSimpleOutputValues() {
GraphSelectionEnum[] selEnumVals=null;
GraphSelectionEnum[] selEnumVals = null;
selEnumVals = GraphSelectionEnum.values();
// else selEnumVals = (GraphSelectionEnum[]) (m_StatsParams.getGraphSelection().getSelectedEnum(GraphSelectionEnum.values()));
Object[] ret = new Object[1+selEnumVals.length];
ret[0]=functionCalls;
for (int i=1; i<=selEnumVals.length; i++) {
switch (selEnumVals[i-1]) { // the field i+1 contains enum value i, because field 0 is reserved for the number of function calls
Object[] ret = new Object[1 + selEnumVals.length];
ret[0] = functionCalls;
for (int i = 1; i <= selEnumVals.length; i++) {
switch (selEnumVals[i - 1]) { // the field i+1 contains enum value i, because field 0 is reserved for the number of function calls
// currentBest, currentWorst, runBest, currentBestFeasible, runBestFeasible, avgPopDistance, maxPopDistance;
case currentBest: ret[i]=currentBestFit[defaultFitCriterion ]; break;
case meanFit: ret[i] = (currentMeanFit==null) ? Double.NaN : currentMeanFit[defaultFitCriterion]; break;
case currentWorst: ret[i] = (currentWorstFit==null) ? Double.NaN : currentWorstFit[defaultFitCriterion]; break;
case runBest: ret[i] = bestOfRunIndy.getFitness()[defaultFitCriterion]; break;
case currentBestFeasible: ret[i] = (currentBestFeasibleFit==null) ? Double.NaN : currentBestFeasibleFit[defaultFitCriterion]; break;
case runBestFeasible: ret[i] = (bestOfRunFeasibleIndy==null) ? Double.NaN : bestOfRunFeasibleIndy.getFitness()[defaultFitCriterion]; break;
case avgEucPopDistance: ret[i] = currentAvgEucDistInPop; break;
case maxEucPopDistance: ret[i] = currentMaxEucDistInPop; break;
case avgPopMetricDist: ret[i] = currentAvgPopDistMetric; break;
case maxPopMetricDist: ret[i] = currentMaxPopDistMetric; break;
case currentBest:
ret[i] = currentBestFit[defaultFitCriterion];
break;
case meanFit:
ret[i] = (currentMeanFit == null) ? Double.NaN : currentMeanFit[defaultFitCriterion];
break;
case currentWorst:
ret[i] = (currentWorstFit == null) ? Double.NaN : currentWorstFit[defaultFitCriterion];
break;
case runBest:
ret[i] = bestOfRunIndy.getFitness()[defaultFitCriterion];
break;
case currentBestFeasible:
ret[i] = (currentBestFeasibleFit == null) ? Double.NaN : currentBestFeasibleFit[defaultFitCriterion];
break;
case runBestFeasible:
ret[i] = (bestOfRunFeasibleIndy == null) ? Double.NaN : bestOfRunFeasibleIndy.getFitness()[defaultFitCriterion];
break;
case avgEucPopDistance:
ret[i] = currentAvgEucDistInPop;
break;
case maxEucPopDistance:
ret[i] = currentMaxEucDistInPop;
break;
case avgPopMetricDist:
ret[i] = currentAvgPopDistMetric;
break;
case maxPopMetricDist:
ret[i] = currentMaxPopDistMetric;
break;
}
}
// all standard fields should be filled now
@@ -908,10 +914,10 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
* names of the corresponding fields in the same order.
* The length of this list depends on the field selection state.
*
* @see #getOutputHeader(List, PopulationInterface)
* @param informerList
* @param pop
* @return
* @see #getOutputHeader(List, PopulationInterface)
*/
protected List<Object> getOutputValues(List<InterfaceAdditionalPopulationInformer> informerList, PopulationInterface pop) {
LinkedList<Object> values = new LinkedList<Object>();
@@ -924,7 +930,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
}
// remove those which are not requested
Iterator<Object> iter = values.iterator();
int cnt=0;
int cnt = 0;
iter.next(); // skip the first field (function calls) which is not regarded here
if (!lastIsShowFull) {
while (iter.hasNext()) {
@@ -949,26 +955,26 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
*/
protected List<String> getAdditionalHeaderMetaInfo(List<InterfaceAdditionalPopulationInformer> informerList, List<String> metaInfo) {
LinkedList<String> headers = new LinkedList<String>();
if (metaInfo!=null && (metaInfo.size()>0)) {
if (metaInfo != null && (metaInfo.size() > 0)) {
System.err.println("Warning, metaInfo list should be empty in AbstractStatistics.getAdditionalHeaderMetaInfo");
}
for (InterfaceAdditionalPopulationInformer informer : informerList) {
headers.addAll(Arrays.asList(informer.getAdditionalDataHeader()));
if (metaInfo!=null) {
if (metaInfo != null) {
metaInfo.addAll(Arrays.asList(informer.getAdditionalDataInfo()));
}
// hdr = hdr + "\t " + informer.getAdditionalDataHeader(pop);
}
Iterator<String> hIter = headers.iterator();
Iterator<String> mIter = (metaInfo!=null) ? metaInfo.iterator() : null;
Iterator<String> mIter = (metaInfo != null) ? metaInfo.iterator() : null;
if (!lastIsShowFull) {
while (hIter.hasNext()) {
if (mIter!=null && mIter.hasNext()) {
if (mIter != null && mIter.hasNext()) {
mIter.next();
}
if (!isRequestedAdditionalField(hIter.next())) {
hIter.remove();
if (mIter!=null && mIter.hasNext()) {
if (mIter != null && mIter.hasNext()) {
mIter.remove();
}
}
@@ -987,11 +993,11 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
* @param pop
* @return
*/
protected Pair<String,Object[]> getOutputData(List<InterfaceAdditionalPopulationInformer> informerList, PopulationInterface pop) {
protected Pair<String, Object[]> getOutputData(List<InterfaceAdditionalPopulationInformer> informerList, PopulationInterface pop) {
List<Object> statValues = getOutputValues(informerList, pop);
String statValuesString = StringTools.concatValues(statValues, textFieldDelimiter);
return new Pair<String,Object[]>(statValuesString, statValues.toArray(new Object[statValues.size()]));
return new Pair<String, Object[]>(statValuesString, statValues.toArray(new Object[statValues.size()]));
}
// /**
@@ -1045,13 +1051,13 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
firstPlot = false;
}
if ((iterationCounter == 0) && printHeaderByVerbosity()) {
printToTextListener(getOutputHeaderFieldNamesAsString(null)+'\n');
printToTextListener(getOutputHeaderFieldNamesAsString(null) + '\n');
}
if (doTextOutput() && printLineByVerbosity(calls)) {
Pair<String,Object[]> addInfo = getOutputData(null, null);
printToTextListener(addInfo.head()+'\n');
if (addInfo.tail()!=null) {
Pair<String, Object[]> addInfo = getOutputData(null, null);
printToTextListener(addInfo.head() + '\n');
if (addInfo.tail() != null) {
statDataSumOverAll = updateSum(statDataSumOverAll, ToolBox.parseDoubles(addInfo.tail()));
}
}
@@ -1067,18 +1073,17 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
* @param curInfo
*/
private static Double[] updateSum(Double[] resultSum, Double[] curInfo) {
if (resultSum==null) {
if (resultSum == null) {
resultSum = curInfo.clone();
} else {
if (curInfo.length != resultSum.length) {
System.err.println("Error in AbstractStatistics.updateAdditionalInfo: mismatching info arrays!");
} else {
for (int i=0; i<curInfo.length; i++) {
if (resultSum[i]==null || (curInfo[i]==null)) {
resultSum[i]=null;
}
else {
resultSum[i]+=curInfo[i];
for (int i = 0; i < curInfo.length; i++) {
if (resultSum[i] == null || (curInfo[i] == null)) {
resultSum[i] = null;
} else {
resultSum[i] += curInfo[i];
}
}
}
@@ -1088,6 +1093,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
/**
* If the population returns a specific data array, this method is called instead of doing standard output
*
* @param pop
* @param informer
*/
@@ -1102,6 +1108,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
/**
* To set a list of informers (even before the actual run is started).
*
* @param informerList
*/
public void setInitialInformerList(List<InterfaceAdditionalPopulationInformer> informerList) {
@@ -1120,8 +1127,8 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
if ((bestIndyAllRuns == null) || (secondIsBetter(bestIndyAllRuns, bestCurrentIndy))) {
bestIndyAllRuns = bestCurrentIndy;
}
if ((bestOfRunIndy==null) || (secondIsBetter(bestOfRunIndy, bestCurrentIndy))) {
bestOfRunIndy=bestCurrentIndy;
if ((bestOfRunIndy == null) || (secondIsBetter(bestOfRunIndy, bestCurrentIndy))) {
bestOfRunIndy = bestCurrentIndy;
}
if (bestCurrentIndy == null) {
System.err.println("createNextGenerationPerformed BestInd==null");
@@ -1131,19 +1138,19 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
System.err.println("BestFitness==null !");
}
if (pop instanceof Population) {
AbstractEAIndividual curBestFeasible = ((Population)pop).getBestFeasibleIndividual(-1);
if (curBestFeasible!=null) { // a feasible ind. was found!
if (currentBestFeasibleFit==null) { // feasible indy found for the first time
AbstractEAIndividual curBestFeasible = ((Population) pop).getBestFeasibleIndividual(-1);
if (curBestFeasible != null) { // a feasible ind. was found!
if (currentBestFeasibleFit == null) { // feasible indy found for the first time
numOfRunsFeasibleFound++;
feasibleFoundAfter=((Population)pop).getFunctionCalls();
if (feasibleFoundAfterSum<0) {
feasibleFoundAfterSum=0.;
feasibleFoundAfter = ((Population) pop).getFunctionCalls();
if (feasibleFoundAfterSum < 0) {
feasibleFoundAfterSum = 0.;
} // initial signaling value was -1.
feasibleFoundAfterSum+=feasibleFoundAfter;
feasibleFoundAfterSum += feasibleFoundAfter;
}
currentBestFeasibleFit = curBestFeasible.getFitness().clone();
if ((bestOfRunFeasibleIndy==null) || (secondIsBetter(bestOfRunFeasibleIndy, curBestFeasible))) {
bestOfRunFeasibleIndy=(AbstractEAIndividual)curBestFeasible.clone();
if ((bestOfRunFeasibleIndy == null) || (secondIsBetter(bestOfRunFeasibleIndy, curBestFeasible))) {
bestOfRunFeasibleIndy = (AbstractEAIndividual) curBestFeasible.clone();
// System.out.println("New best feasible: " + AbstractEAIndividual.getDefaultStringRepresentation((AbstractEAIndividual)bestRunFeasibleIndy));
}
if ((bestFeasibleAllRuns == null) || (secondIsBetter(bestFeasibleAllRuns, bestOfRunFeasibleIndy))) {
@@ -1157,14 +1164,12 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
// collect these data fields only if requested by the user
if (lastIsShowFull || GraphSelectionEnum.doPlotMean(lastFieldSelection)) {
currentMeanFit = pop.getMeanFitness().clone();
}
else {
} else {
currentMeanFit = null;
}
if (lastIsShowFull || GraphSelectionEnum.doPlotWorst(lastFieldSelection)) {
currentWorstFit = pop.getWorstIndividual().getFitness().clone();
}
else {
} else {
currentWorstFit = null;
}
@@ -1172,7 +1177,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
if (lastIsShowFull || GraphSelectionEnum.doPlotAvgEucDist(lastFieldSelection)
|| GraphSelectionEnum.doPlotMaxEucDist(lastFieldSelection)) {
double[] measures = ((Population)pop).getPopulationMeasures((InterfaceDistanceMetric)null);
double[] measures = ((Population) pop).getPopulationMeasures((InterfaceDistanceMetric) null);
if (measures != null) {
currentAvgEucDistInPop = measures[0];
currentMaxEucDistInPop = measures[2];
@@ -1181,7 +1186,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
if (lastIsShowFull || GraphSelectionEnum.doPlotAvgPopMetricDist(lastFieldSelection)
|| GraphSelectionEnum.doPlotMaxPopMetricDist(lastFieldSelection)) {
double[] measures = ((Population)pop).getPopulationMeasures();
double[] measures = ((Population) pop).getPopulationMeasures();
if (measures != null) {
currentAvgPopDistMetric = measures[0];
currentMaxPopDistMetric = measures[2];
@@ -1196,15 +1201,12 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
/**
* Do some data collection on the population.
*
*/
@Override
public synchronized void createNextGenerationPerformed(PopulationInterface
pop, InterfaceOptimizer opt, List<InterfaceAdditionalPopulationInformer> informerList) {
lastInformerList = informerList;
if (TRACE) {
printToTextListener(".. in createNextGenPerformed after " + pop.getFunctionCalls() + " evals.\n");
}
if (resultOut != null) {
resultOut.flush();
}
@@ -1212,7 +1214,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
initPlots(pop, informerList);
// if (doTextOutput()) printToTextListener(getOutputHeader(informer, pop)+'\n');
firstPlot = false;
currentBestFeasibleFit=null;
currentBestFeasibleFit = null;
}
if (pop.getSpecificData() != null) { // this is more or less deprecated. the standard population implementation will always return null. However the ES module wont
@@ -1222,27 +1224,27 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
collectPopData(pop);
if (iterationCounter==0) {
if (iterationCounter == 0) {
String headerLine = StringTools.concatFields(currentStatHeader, textFieldDelimiter);
if (printHeaderByVerbosity()) {
printToTextListener(headerLine+'\n');
printToTextListener(headerLine + '\n');
}
}
lastSols = (opt!=null) ? new Population(opt.getAllSolutions().getSolutions()) : pop;
lastSols = (opt != null) ? new Population(opt.getAllSolutions().getSolutions()) : pop;
// Pair<String,Double[]> addData = getOutputData(informerList, lastSols);
// System.out.println("lastSols size: " + 500*PSymbolicRegression.getAvgIndySize(lastSols));
// System.out.println("Mem use: " + getMemoryUse());
Pair<String,Object[]> addData = getOutputData(informerList, lastSols);
Pair<String, Object[]> addData = getOutputData(informerList, lastSols);
if (doTextOutput()) { // this is where the text output is actually written
if (printLineByVerbosity(iterationCounter)) {
// printToTextListener(functionCalls + textFieldDelimiter);
printToTextListener(addData.head()+'\n');
printToTextListener(addData.head() + '\n');
}
}
currentStatObjectData = addData.tail();
currentStatDoubleData = ToolBox.parseDoubles(currentStatObjectData);
if (currentStatObjectData!=null) {
if (currentStatObjectData != null) {
statDataSumOverAll = updateSum(statDataSumOverAll, currentStatDoubleData); // this adds up all data of a single run
} else {
System.err.println("Warning in AbstractStatistics!");
@@ -1251,14 +1253,14 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
if (sumDataCollection != null) {
// Collect average data
Double[] sumDataEntry = null;
if ((optRunsPerformed==0) && (sumDataCollection.size()<=iterationCounter)) {
if ((optRunsPerformed == 0) && (sumDataCollection.size() <= iterationCounter)) {
// in the first run, newly allocate the arrays
// assume that all later data sets will have the same format
// means = new double[4][currentBestFit.length]; // this only fits fitness vectors! of course this is sensible for multi-crit fitnesses...
sumDataEntry = currentStatDoubleData.clone();
sumDataCollection.add(sumDataEntry);
} else {
if (sumDataCollection.size()<=iterationCounter) {// bad case!
if (sumDataCollection.size() <= iterationCounter) {// bad case!
// may happen for dynamic pop-sizes, e.g. in Tribes, when runs do not necessarily send the
// "generation performed" event the same number of times.
// thus: dont do an update for events that are "too late"
@@ -1285,9 +1287,6 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
// }
plotCurrentResults();
fireDataListeners();
if (TRACE) {
printToTextListener(".. done createNextGenPerformed after " + pop.getFunctionCalls() + " evals.\n");
}
if (resultOut != null) {
resultOut.flush();
}
@@ -1309,7 +1308,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
private boolean printRunIntroVerbosity() {
return (m_StatsParams.getOutputVerbosity().getSelectedTagID() >= StatisticsParameter.VERBOSITY_KTH_IT)
|| (optRunsPerformed==0 && (m_StatsParams.getOutputVerbosity().getSelectedTagID() >= StatisticsParameter.VERBOSITY_FINAL));
|| (optRunsPerformed == 0 && (m_StatsParams.getOutputVerbosity().getSelectedTagID() >= StatisticsParameter.VERBOSITY_FINAL));
}
private boolean printRunStoppedVerbosity() {
@@ -1324,15 +1323,14 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
// ingeniously shifting i by two since the stats counter starts at 0
// after two evaluations have already happened: initialization and first optimization
// this allows the last iteration to be within the displayed set if k is a divisor of whole iterations as expected
if ((i==0) || (k==0)) {
if ((i == 0) || (k == 0)) {
return true;
}
else {
if (i<=2) {
} else {
if (i <= 2) {
return (i % k) == 0;
} // show more at the beginning (always first time)
else {
return ((i+2) % k) == 0;
return ((i + 2) % k) == 0;
}
}
}
@@ -1342,8 +1340,8 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
}
private static void divideMean(Double[] mean, double d) {
for (int j=0; j<mean.length; j++) {
if (mean[j]!=null) {
for (int j = 0; j < mean.length; j++) {
if (mean[j] != null) {
mean[j] /= d;
}
}
@@ -1367,7 +1365,7 @@ l.notifyGenerationPerformed(currentStatHeader, currentStatObjectData, currentSta
return false;
}
if (indy1 instanceof AbstractEAIndividual) {
return ((AbstractEAIndividual)indy2).isDominatingDebConstraints((AbstractEAIndividual)indy1);
return ((AbstractEAIndividual) indy2).isDominatingDebConstraints((AbstractEAIndividual) indy1);
}
return (indy2.isDominant(indy1));
}

46
src/eva2/optimization/stat/InterfaceStatistics.java
View File

@@ -1,26 +1,12 @@
package eva2.optimization.stat;
/*
* Title: EvA2
* Description:
* Copyright: Copyright (c) 2003
* Company: University of Tuebingen, Computer Architecture
* @author Holger Ulmer, Felix Streichert, Hannes Planatscher
* @version: $Revision: 306 $
* $Date: 2007-12-04 14:22:52 +0100 (Tue, 04 Dec 2007) $
* $Author: mkron $
*/
/*==========================================================================*
* IMPORTS
*==========================================================================*/
import eva2.optimization.go.IndividualInterface;
import eva2.optimization.population.PopulationInterface;
import eva2.optimization.population.Population;
import eva2.optimization.problems.InterfaceAdditionalPopulationInformer;
import eva2.optimization.strategies.InterfaceOptimizer;
import java.util.List;
/*==========================================================================*
* INTERFACE DECLARATION
*==========================================================================*/
/**
*
*/
@@ -28,21 +14,21 @@ public interface InterfaceStatistics {
/**
* Initialize statistics computations.
*/
public void startOptPerformed(String InfoString,int runnumber, Object params, List<InterfaceAdditionalPopulationInformer> informerList); // called from processor
void startOptPerformed(String InfoString,int runnumber, Object params, List<InterfaceAdditionalPopulationInformer> informerList); // called from processor
/**
* Finalize statistics computations.
*/
public void stopOptPerformed(boolean normal, String stopMessage); // called from processor
public void addDataListener(InterfaceStatisticsListener listener);
public boolean removeDataListener(InterfaceStatisticsListener listener);
public void addTextListener(InterfaceTextListener listener);
public boolean removeTextListener(InterfaceTextListener listener);
public void printToTextListener(String s);
public void createNextGenerationPerformed(PopulationInterface Pop, InterfaceOptimizer opt, List<InterfaceAdditionalPopulationInformer> informerList);
public void createNextGenerationPerformed(double[] bestfit,double[] worstfit,int calls);
public InterfaceStatisticsParameter getStatisticsParameter(); // called from moduleadapter
public IndividualInterface getRunBestSolution(); // return the best fitness of the last run (may not be equal to the last population)
public IndividualInterface getBestSolution(); // returns the best overall solution
public double[] getBestFitness(); // returns the best overall fitness
public void postProcessingPerformed(Population resultPop); // called from processor
void stopOptPerformed(boolean normal, String stopMessage); // called from processor
void addDataListener(InterfaceStatisticsListener listener);
boolean removeDataListener(InterfaceStatisticsListener listener);
void addTextListener(InterfaceTextListener listener);
boolean removeTextListener(InterfaceTextListener listener);
void printToTextListener(String s);
void createNextGenerationPerformed(PopulationInterface Pop, InterfaceOptimizer opt, List<InterfaceAdditionalPopulationInformer> informerList);
void createNextGenerationPerformed(double[] bestfit,double[] worstfit,int calls);
InterfaceStatisticsParameter getStatisticsParameter(); // called from moduleadapter
IndividualInterface getRunBestSolution(); // return the best fitness of the last run (may not be equal to the last population)
IndividualInterface getBestSolution(); // returns the best overall solution
double[] getBestFitness(); // returns the best overall fitness
void postProcessingPerformed(Population resultPop); // called from processor
}

18
src/eva2/optimization/stat/MovingAverage.java
View File

@@ -1,20 +1,6 @@
package eva2.optimization.stat;
/*
* Title: EvA2
* Description:
* Copyright: Copyright (c) 2003
* Company: University of Tuebingen, Computer Architecture
* @author Holger Ulmer, Felix Streichert, Hannes Planatscher
* @version: $Revision: 16 $
* $Date: 2006-12-20 10:42:57 +0100 (Wed, 20 Dec 2006) $
* $Author: marcekro $
*/
/*==========================================================================*
* IMPORTS
*==========================================================================*/
/*==========================================================================*
* INTERFACE DECLARATION
*==========================================================================*/
/**
*
*/

3
src/eva2/optimization/stat/StatisticsStandalone.java
View File

@@ -105,9 +105,6 @@ public class StatisticsStandalone extends AbstractStatistics implements Interfac
@Override
public void plotSpecificData(PopulationInterface pop, List<InterfaceAdditionalPopulationInformer> informerList) {
if (TRACE) {
System.out.println(" m_SpecificData !!");
}
double[] specificData = pop.getSpecificData();
if (specificData != null) {
for (int i = 0; i < specificData.length; i++) {

2
src/eva2/optimization/tools/GeneralGEOFaker.java
View File

@@ -71,7 +71,7 @@ public class GeneralGEOFaker extends JPanel {
// edit.setEnabled(false);
// m_SourceCodeEditor = new SourceCodeEditor();
// String className = m_Editor.getValue().getClass().getName();
// m_SourceCodeEditor.editSource(EvAClient.DYNAMICCLASSES_PROPERTIES.getProperty(className));
// m_SourceCodeEditor.editSource(Main.DYNAMICCLASSES_PROPERTIES.getProperty(className));
// m_SourceCodeEditorFrame = new PropertyDialog(m_SourceCodeEditor, "test", 50, 50);
// m_SourceCodeEditorFrame.pack();
// m_SourceCodeEditorFrame.addWindowListener(new WindowAdapter() {

2
src/eva2/optimization/tools/GeneralGenericObjectEditorPanel.java
View File

@@ -99,7 +99,7 @@ public class GeneralGenericObjectEditorPanel extends JPanel implements ItemListe
// m_editSourceBut.setEnabled(false);
// m_SourceCodeEditor = new SourceCodeEditor();
// String className = m_ObjectEditor.getValue().getClass().getName();
// m_SourceCodeEditor.editSource(EvAClient.DYNAMICCLASSES_PROPERTIES.getProperty(className));
// m_SourceCodeEditor.editSource(Main.DYNAMICCLASSES_PROPERTIES.getProperty(className));
// m_SourceCodeEditorFrame = new PropertyDialog(m_SourceCodeEditor, "test", 50, 50);
// m_SourceCodeEditorFrame.pack();
// m_SourceCodeEditorFrame.addWindowListener(new WindowAdapter() {

2
src/eva2/tools/EVAERROR.java
View File

@@ -47,7 +47,7 @@ public class EVAERROR {
* Send a message only once to System.err. Once means that the msg is stored for the lifetime of
* the VM or until clearMsgCache() is called.
*
* @param msg
* @param message
*/
public static void errorMsgOnce(String message) {
if (errorMap == null) {

2
src/eva2/tools/ReflectPackage.java
View File

@@ -464,7 +464,7 @@ public class ReflectPackage {
// BasicResourceLoader rld = BasicResourceLoader.instance();
// byte[] b = rld.getBytesFromResourceLocation("images/Sub24.gif");
// System.out.println((b == null) ? "null" : b.toString());
// b = rld.getBytesFromResourceLocation("src/eva2/client/EvAClient.java");
// b = rld.getBytesFromResourceLocation("src/eva2/client/SplashScreen.java");
// System.out.println((b == null) ? "null" : b.toString());
HashSet<String> h = new HashSet<String> (20);

2
src/eva2/tools/StringTools.java
View File

@@ -19,7 +19,7 @@ public final class StringTools {
private StringTools() { }
/**
* Returns a HTML formated String, in which each line is at most lineBreak
* Returns a HTML formatted String, in which each line is at most lineBreak
* symbols long.
*
* @param string