diff options
23 files changed, 1321 insertions, 262 deletions
diff --git a/src/cgp0.chr b/src/cgp0.chr new file mode 100644 index 0000000..3157c03 --- /dev/null +++ b/src/cgp0.chr @@ -0,0 +1 @@ + 1 2 7 1 2 6 2 2 7 3 2 7 2 0 7 3 0 7 0 1 7 7 1 10 6 0 7 10 11 7 2 11 7 0 11 6 13 0 7 13 12 10 14 1 7 16
\ No newline at end of file diff --git a/src/jcgp/JCGP.java b/src/jcgp/JCGP.java index e124dbf..1e847fb 100644 --- a/src/jcgp/JCGP.java +++ b/src/jcgp/JCGP.java @@ -1,5 +1,7 @@ package jcgp; +import java.io.File; + import jcgp.backend.modules.es.EvolutionaryStrategy; import jcgp.backend.modules.es.MuPlusLambda; import jcgp.backend.modules.es.TournamentSelection; @@ -8,6 +10,11 @@ import jcgp.backend.modules.mutator.PointMutator; import jcgp.backend.modules.problem.DigitalCircuit; import jcgp.backend.modules.problem.Problem; import jcgp.backend.modules.problem.SymbolicRegression; +import jcgp.backend.modules.problem.TestCaseProblem; +import jcgp.backend.parser.ChromosomeParser; +import jcgp.backend.parser.FunctionParser; +import jcgp.backend.parser.ParameterParser; +import jcgp.backend.parser.TestCaseParser; import jcgp.backend.population.Population; import jcgp.backend.resources.Console; import jcgp.backend.resources.ModifiableResources; @@ -16,13 +23,13 @@ import jcgp.backend.resources.Resources; /** * * Top-level CGP class. This class is the entry point for a CGP experiment. - * <p> + * <br> * An instance of JCGP encapsulates the entire experiment. It contains a Resources * object which can be retrieved via a getter. Modules can be selected using their * respective setters and function sets can be selected through the resources. * * The flow of the experiment is controlled using start() and nextGeneration(). The - * experiment can be reset with reset(), + * experiment can be reset with reset(), TODO comment * * * @author Eduardo Pedroni @@ -48,7 +55,7 @@ public class JCGP { // evolutionary algorithms private EvolutionaryStrategy[] evolutionaryStrategies = new EvolutionaryStrategy[] { new MuPlusLambda(resources), - new TournamentSelection()}; + new TournamentSelection() }; private EvolutionaryStrategy evolutionaryStrategy; // problem types @@ -63,6 +70,26 @@ public class JCGP { private Population population; private boolean finished = false; + /** + * TODO comment this! + * + * @param args + */ + public static void main(String... args) { + if (args.length < 1) { + System.err.println("JCGP requires at least a .par file."); + System.exit(1); + } + JCGP jcgp = new JCGP(); + jcgp.loadParameters(new File(args[0])); + + if (jcgp.getProblem() instanceof TestCaseProblem) { + TestCaseParser.parse(new File(args[2]), (TestCaseProblem<?>) jcgp.getProblem()); + } + + jcgp.start(); + } + public JCGP() { setEvolutionaryStrategy(0); setMutator(0); @@ -154,7 +181,7 @@ public class JCGP { public void nextGeneration() { if (!finished) { problem.evaluate(population, (Resources) resources); - report(); + reportGeneration(); if (resources.currentGeneration() < resources.generations()) { // we still have generations left to go @@ -200,24 +227,20 @@ public class JCGP { } - private void report() { - if (resources.report() > 0) { - if (resources.currentGeneration() % resources.report() == 0) { - resources.println("[CGP] Generation: " + resources.currentGeneration() + ", fitness: " + population.getFittest().getFitness()); + private void reportGeneration() { + if (resources.reportInterval() > 0) { + if (resources.currentGeneration() % resources.reportInterval() == 0) { + resources.println("[CGP] Generation: " + resources.currentGeneration()); } } } public void start() { if (!finished) { - while (resources.currentGeneration() <= resources.generations()) { + while (!finished) { nextGeneration(); - if (finished) { - break; - } } } - } public void reset() { @@ -228,6 +251,26 @@ public class JCGP { resources.println("-----------------------------"); resources.println("New experiment: " + problem.toString()); } + + public void loadParameters(File file) { + ParameterParser.parseParameters(file, resources); + FunctionParser.parseFunctions(file, problem); + reset(); + } + + public void loadTestCases(File file) { + if (problem instanceof TestCaseProblem) { + TestCaseParser.parse(file, (TestCaseProblem<?>) problem); + } + } + + public void loadChromosome(File file) { + ChromosomeParser.parse(file, population.getChromosome(0), resources); + } + + public void saveChromosome(File file, int chromosomeIndex) { + ChromosomeParser.save(file, population.getChromosome(chromosomeIndex)); + } public boolean isFinished() { return finished; @@ -236,5 +279,4 @@ public class JCGP { public void setConsole(Console console) { resources.setConsole(console); } - } diff --git a/src/jcgp/backend/function/BitwiseLogic.java b/src/jcgp/backend/function/BitwiseLogic.java index 5d47ff7..14f4488 100644 --- a/src/jcgp/backend/function/BitwiseLogic.java +++ b/src/jcgp/backend/function/BitwiseLogic.java @@ -1,6 +1,5 @@ package jcgp.backend.function; -import jcgp.backend.exceptions.InvalidArgumentsException; import jcgp.backend.population.Connection; public class BitwiseLogic extends FunctionSet { @@ -8,26 +7,155 @@ public class BitwiseLogic extends FunctionSet { public BitwiseLogic() { name = "32-bit Logic"; functionList = new Function[]{ + new ConstantZero(), + new ConstantOne(), + new WireA(), + new WireB(), + new NotA(), + new NotB(), new And(), - new Or(), - new Not(), - new Xor(), - new Nand(), + new AndNotA(), + new AndNotB(), new Nor(), - new Xnor()}; + new Xor(), + new Xnor(), + new Or(), + new OrNotA(), + new OrNotB(), + new Nand()}; + + // TODO muxes enableAll(); } + + public static class ConstantZero extends Function { + @Override + public Long run(Connection... connections) { + return new Long(0); + } + + @Override + public int getArity() { + return 0; + } + + @Override + public String getName() { + return "0"; + } + } + + public static class ConstantOne extends Function { + @Override + public Long run(Connection... connections) { + return new Long(Long.MAX_VALUE); + } + + @Override + public int getArity() { + return 0; + } + + @Override + public String getName() { + return "1"; + } + } + + public static class WireA extends Function { + @Override + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + return ((Long) connections[0].getValue()).longValue(); + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Wire A"; + } + } + + public static class WireB extends Function { + @Override + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + return ((Long) connections[1].getValue()).longValue(); + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Wire B"; + } + } + + public static class NotA extends Function { + @Override + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + return ~((Long) connections[0].getValue()).longValue(); + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Not A"; + } + } + + public static class NotB extends Function { + @Override + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + return ~((Long) connections[1].getValue()).longValue(); + } + } + + @Override + public int getArity() { + return 2; + } + @Override + public String getName() { + return "Not B"; + } + } + public static class And extends Function { @Override - public Object run(Connection... connections) { - if (connections.length < 2) { - throw new InvalidArgumentsException("Not enough connections were given."); + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); } else { - int arg1 = ((int) connections[0].getValue()); - int arg2 = ((int) connections[1].getValue()); - int result = arg1 & arg2; + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = arg1 & arg2; return result; } @@ -40,20 +168,20 @@ public class BitwiseLogic extends FunctionSet { @Override public String getName() { - return "AND"; + return "And"; } } - public static class Or extends Function { + public static class AndNotA extends Function { @Override - public Object run(Connection... connections) { - if (connections.length < 2) { - throw new InvalidArgumentsException("Not enough connections were given."); + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); } else { - int arg1 = ((int) connections[0].getValue()); - int arg2 = ((int) connections[1].getValue()); - int result = arg1 | arg2; - + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = ~arg1 & arg2; + return result; } } @@ -65,43 +193,69 @@ public class BitwiseLogic extends FunctionSet { @Override public String getName() { - return "OR"; + return "And !A"; } } - - public static class Not extends Function { + + public static class AndNotB extends Function { @Override - public Object run(Connection... connections) { - if (connections.length < 1) { - throw new InvalidArgumentsException("Not enough connections were given."); + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); } else { - int arg1 = ((int) connections[0].getValue()); - int result = ~arg1; - + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = arg1 & ~arg2; + return result; } } @Override public int getArity() { - return 1; + return 2; } @Override public String getName() { - return "NOT"; + return "And !B"; } } + + public static class Nor extends Function { + @Override + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = arg1 | arg2; + return ~result; + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Nor"; + } + } + public static class Xor extends Function { @Override - public Object run(Connection... connections) { - if (connections.length < 2) { - throw new InvalidArgumentsException("Not enough connections were given."); + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); } else { - int arg1 = ((int) connections[0].getValue()); - int arg2 = ((int) connections[1].getValue()); - int result = arg1 ^ arg2; + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = arg1 ^ arg2; return result; } @@ -114,19 +268,19 @@ public class BitwiseLogic extends FunctionSet { @Override public String getName() { - return "XOR"; + return "Xor"; } } - - public static class Nand extends Function { + + public static class Xnor extends Function { @Override - public Object run(Connection... connections) { - if (connections.length < 2) { - throw new InvalidArgumentsException("Not enough connections were given."); + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); } else { - int arg1 = ((int) connections[0].getValue()); - int arg2 = ((int) connections[1].getValue()); - int result = arg1 & arg2; + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = arg1 ^ arg2; return ~result; } @@ -139,21 +293,71 @@ public class BitwiseLogic extends FunctionSet { @Override public String getName() { - return "NAND"; + return "Xnor"; } } + + public static class Or extends Function { + @Override + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = arg1 | arg2; - public static class Nor extends Function { + return result; + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Or"; + } + } + + public static class OrNotA extends Function { @Override - public Object run(Connection... connections) { - if (connections.length < 2) { - throw new InvalidArgumentsException("Not enough connections were given."); + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); } else { - int arg1 = ((int) connections[0].getValue()); - int arg2 = ((int) connections[1].getValue()); - int result = arg1 | arg2; + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = ~arg1 | arg2; - return ~result; + return result; + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Or !A"; + } + } + + public static class OrNotB extends Function { + @Override + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = arg1 | ~arg2; + + return result; } } @@ -164,19 +368,19 @@ public class BitwiseLogic extends FunctionSet { @Override public String getName() { - return "NOR"; + return "Or !B"; } } - public static class Xnor extends Function { + public static class Nand extends Function { @Override - public Object run(Connection... connections) { - if (connections.length < 2) { - throw new InvalidArgumentsException("Not enough connections were given."); + public Long run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); } else { - int arg1 = ((int) connections[0].getValue()); - int arg2 = ((int) connections[1].getValue()); - int result = arg1 ^ arg2; + Long arg1 = ((Long) connections[0].getValue()); + Long arg2 = ((Long) connections[1].getValue()); + Long result = arg1 & arg2; return ~result; } @@ -189,10 +393,7 @@ public class BitwiseLogic extends FunctionSet { @Override public String getName() { - return "XNOR"; + return "Nand"; } } - - - } diff --git a/src/jcgp/backend/function/DoubleArithmetic.java b/src/jcgp/backend/function/DoubleArithmetic.java new file mode 100644 index 0000000..ce4826f --- /dev/null +++ b/src/jcgp/backend/function/DoubleArithmetic.java @@ -0,0 +1,589 @@ +package jcgp.backend.function; + +import jcgp.backend.population.Connection; + +public class DoubleArithmetic extends FunctionSet { + + public final static double DIVISION_LIMIT = 0.0001; + + public DoubleArithmetic() { + name = "Double Arithmetic"; + functionList = new Function[]{ + new Absolute(), + new SquareRoot(), + new Reciprocal(), + new Sine(), + new Cosine(), + new Tangent(), + new Exponential(), + new HyperbolicSine(), + new HyperbolicCosine(), + new HyperbolicTangent(), + new NaturalLog(), + new LogBaseTen(), + new SineAB(), + new CosineAB(), + new Hypotenuse(), + new Power(), + new Addition(), + new Subtraction(), + new Multiplication(), + new Division()}; + + enableAll(); + } + + /** + * Absolute returns the positive value of input 0. + * + * @see Math.abs() + */ + public static class Absolute extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return Math.abs(in0); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Absolute"; + } + } + + /** + * Protected square root function, returns the square root of the absolute + * value of input 0. + * + * @see Math.abs(), Math.sqrt() + */ + public static class SquareRoot extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return Math.sqrt(Math.abs(in0)); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Square root"; + } + } + + /** + * Protected reciprocal function, returns (1 / input 0). If input 0 is less than + * {@link DoubleArithmetic.}DIVISION_LIMIT, this returns it unchanged. + * + */ + public static class Reciprocal extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return in0 < DIVISION_LIMIT ? in0 : (1 / in0); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Reciprocal"; + } + } + + /** + * Sine function, in radians. + * + * @see Math.sin() + */ + public static class Sine extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return Math.sin(in0); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Sin"; + } + } + + /** + * Cosine function, in radians. + * + * @see Math.cos() + */ + public static class Cosine extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return Math.cos(in0); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Cos"; + } + } + + /** + * Protected tangent function, in radians. Returns the tangent of input 0. + * If input 0 is less than {@link DoubleArithmetic.}DIVISION_LIMIT, + * this returns it unchanged. + * + * @see Math.tan() + */ + public static class Tangent extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return in0 < DIVISION_LIMIT ? in0 : Math.tan(in0); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Tan"; + } + } + + /** + * Exponential function. Returns the exponential of input 0. + * + * @see Math.exp() + */ + public static class Exponential extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return Math.exp(in0); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Exp"; + } + } + + /** + * Returns the hyperbolic sine of input 0. + * + * @see Math.sinh() + */ + public static class HyperbolicSine extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return Math.sinh(in0); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Sinh"; + } + } + + /** + * Returns the hyperbolic cosine of input 0. + * + * @see Math.cosh() + */ + public static class HyperbolicCosine extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return Math.cosh(in0); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Cosh"; + } + } + + /** + * Returns the hyperbolic tangent of input 0. + * + * @see Math.tanh() + */ + public static class HyperbolicTangent extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return Math.tanh(in0); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Tanh"; + } + } + + /** + * Protected natural log function. Returns the natural log of the absolute + * value of input 0. If input 0 is less than {@link DoubleArithmetic.}DIVISION_LIMIT, + * this returns it unchanged. + * + * @see Math.log(), Math.abs() + */ + public static class NaturalLog extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return in0 < DIVISION_LIMIT ? in0 : Math.log(Math.abs(in0)); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Ln"; + } + } + + /** + * Protected log base 10 function. Returns the log to base 10 the absolute + * value of input 0. If input 0 is less than {@link DoubleArithmetic.}DIVISION_LIMIT, + * this returns it unchanged. + * + * @see Math.log10(), Math.abs() + */ + public static class LogBaseTen extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + return in0 < DIVISION_LIMIT ? in0 : Math.log10(Math.abs(in0)); + } + } + + @Override + public int getArity() { + return 1; + } + + @Override + public String getName() { + return "Log"; + } + } + + /** + * Sine of sum. Returns the sine of the sum of inputs 0 and 1. + * + * @see Math.sin() + */ + public static class SineAB extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + Double in1 = ((Double) connections[1].getValue()); + return Math.sin(in0 + in1); + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Sin(a+b)"; + } + } + + /** + * Cosine of sum. Returns the cosine of the sum of inputs 0 and 1. + * + * @see Math.cos() + */ + public static class CosineAB extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + Double in1 = ((Double) connections[1].getValue()); + return Math.cos(in0 + in1); + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Cos(a+b)"; + } + } + + /** + * Hypotenuse function. Returns the square root of input 0 squared + * plus input 1 squared. + * + * @see Math.hypot() + */ + public static class Hypotenuse extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + Double in1 = ((Double) connections[1].getValue()); + return Math.hypot(in0, in1); + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Hypotenuse"; + } + } + + /** + * Power function. Returns the absolute value of input 0 to the power of input 1. + * + * @see Math.abs(), Math.pow + */ + public static class Power extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + Double in1 = ((Double) connections[1].getValue()); + return Math.pow(Math.abs(in0), in1); + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Power"; + } + } + + /** + * Addition returns the sum of inputs 0 and 1. + * + */ + public static class Addition extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + Double in1 = ((Double) connections[1].getValue()); + return in0 + in1; + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Addition"; + } + } + + /** + * Subtraction returns the difference between inputs 0 and 1. + * + */ + public static class Subtraction extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + Double in1 = ((Double) connections[1].getValue()); + return in0 - in1; + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Subtraction"; + } + } + + /** + * Multiplication returns the product of inputs 0 and 1. + * + */ + public static class Multiplication extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + Double in1 = ((Double) connections[1].getValue()); + return in0 * in1; + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Multiplication"; + } + } + + /** + * Protected division, returns the quotient of input 0 (the dividend) and input 1 (the divisor). + * If the divisor is less than {@link DoubleArithmetic.}DIVISION_LIMIT, this returns the it unchanged. + * + */ + public static class Division extends Function { + @Override + public Double run(Connection... connections) { + if (connections.length < getArity()) { + throw new IllegalArgumentException(getName() + " received " + connections.length + " connections but arity is " + getArity() + "."); + } else { + Double in0 = ((Double) connections[0].getValue()); + Double in1 = ((Double) connections[1].getValue()); + + return in1 < DIVISION_LIMIT ? in0 : (in0 / in1); + } + } + + @Override + public int getArity() { + return 2; + } + + @Override + public String getName() { + return "Division"; + } + } +} diff --git a/src/jcgp/backend/function/FunctionSet.java b/src/jcgp/backend/function/FunctionSet.java index 78801fc..1712b51 100644 --- a/src/jcgp/backend/function/FunctionSet.java +++ b/src/jcgp/backend/function/FunctionSet.java @@ -51,6 +51,7 @@ public abstract class FunctionSet { int function = iterator.next(); if (function == index) { iterator.remove(); + break; } } } else { diff --git a/src/jcgp/backend/function/IntegerArithmetic.java b/src/jcgp/backend/function/IntegerArithmetic.java deleted file mode 100644 index 9bb02b5..0000000 --- a/src/jcgp/backend/function/IntegerArithmetic.java +++ /dev/null @@ -1,122 +0,0 @@ -package jcgp.backend.function; - -import jcgp.backend.population.Connection; - -public class IntegerArithmetic extends FunctionSet { - - public IntegerArithmetic() { - name = "Integer Arithmetic"; - functionList = new Function[]{ - new Addition(), - new Subtraction(), - new Multiplication(), - new Division()}; - - enableAll(); - } - - public static class Addition extends Function { - @Override - public Integer run(Connection... connections) { - if (connections.length < 2) { - throw new IllegalArgumentException("Not enough connections were given."); - } else { - Integer arg1 = ((Integer) connections[0].getValue()); - Integer arg2 = ((Integer) connections[1].getValue()); - Integer result = arg1 + arg2; - - return result; - } - } - - @Override - public int getArity() { - return 2; - } - - @Override - public String getName() { - return "Addition"; - } - } - - public static class Subtraction extends Function { - @Override - public Integer run(Connection... connections) { - if (connections.length < 2) { - throw new IllegalArgumentException("Not enough connections were given."); - } else { - Integer arg1 = ((Integer) connections[0].getValue()); - Integer arg2 = ((Integer) connections[1].getValue()); - Integer result = arg1 - arg2; - - return result; - } - } - - @Override - public int getArity() { - return 2; - } - - @Override - public String getName() { - return "Subtraction"; - } - } - - public static class Multiplication extends Function { - @Override - public Integer run(Connection... connections) { - if (connections.length < 2) { - throw new IllegalArgumentException("Not enough connections were given."); - } else { - Integer arg1 = ((Integer) connections[0].getValue()); - Integer arg2 = ((Integer) connections[1].getValue()); - Integer result = arg1 * arg2; - return result; - } - } - - @Override - public int getArity() { - return 2; - } - - @Override - public String getName() { - return "Multiplication"; - } - } - - public static class Division extends Function { - @Override - public Integer run(Connection... connections) { - if (connections.length < 2) { - throw new IllegalArgumentException("Not enough connections were given."); - } else { - Integer arg1 = ((Integer) connections[0].getValue()); - Integer arg2 = ((Integer) connections[1].getValue()); - Integer result; - if (arg2 == 0) { - result = 0; - } else { - result = arg1 / arg2; - } - - return result; - } - } - - @Override - public int getArity() { - return 2; - } - - @Override - public String getName() { - return "Division"; - } - } - -} diff --git a/src/jcgp/backend/modules/problem/SymbolicRegression.java b/src/jcgp/backend/modules/problem/SymbolicRegression.java index c92d183..46b8e09 100644 --- a/src/jcgp/backend/modules/problem/SymbolicRegression.java +++ b/src/jcgp/backend/modules/problem/SymbolicRegression.java @@ -2,18 +2,18 @@ package jcgp.backend.modules.problem; import java.util.ArrayList; -import jcgp.backend.function.IntegerArithmetic; +import jcgp.backend.function.DoubleArithmetic; import jcgp.backend.resources.Resources; -public class SymbolicRegression extends TestCaseProblem<Integer> { +public class SymbolicRegression extends TestCaseProblem<Double> { public SymbolicRegression(Resources resources) { super(resources); - functionSet = new IntegerArithmetic(); + functionSet = new DoubleArithmetic(); - ArrayList<TestCase<Integer>> tc = new ArrayList<TestCase<Integer>>(); - tc.add(new TestCase<Integer>(new Integer[]{1, 2, 3}, new Integer[]{-4, 5, 6})); - tc.add(new TestCase<Integer>(new Integer[]{3, 2, 5}, new Integer[]{2, 5, 9})); + ArrayList<TestCase<Double>> tc = new ArrayList<TestCase<Double>>(); + tc.add(new TestCase<Double>(new Double[]{1.0, 2.0, 3.0}, new Double[]{-4.0, 5.0, 6.0})); + tc.add(new TestCase<Double>(new Double[]{3.0, 2.0, 5.0}, new Double[]{2.0, 5.0, 9.0})); setTestCases(tc); } diff --git a/src/jcgp/backend/parser/ChromosomeParser.java b/src/jcgp/backend/parser/ChromosomeParser.java new file mode 100644 index 0000000..74f638c --- /dev/null +++ b/src/jcgp/backend/parser/ChromosomeParser.java @@ -0,0 +1,131 @@ +package jcgp.backend.parser; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.util.Scanner; + +import jcgp.backend.population.Chromosome; +import jcgp.backend.population.Connection; +import jcgp.backend.population.Node; +import jcgp.backend.resources.Resources; + +/** + * This class includes a method for parsing .chr files and another + * for writing .chr files from given chromosomes. + * + * @author Eduardo Pedroni + * + */ +public class ChromosomeParser { + + /** + * Use this method to parse .chr files into a given chromosome. + * <br><br> + * This is not fully defensive as it doesn't check for number of inputs, + * doesn't compare rows and columns individually and doesn't account for levels back. It + * is not viable to implement these defensive measures with the chromosome format used + * by CGP. + * + * @param file the .chr file to parse from + * @param chromosome the chromosome to configure + * @param resources the experiment resources + */ + public static void parse(File file, Chromosome chromosome, Resources resources) { + /* + * Count the nodes to make sure the size of the .chr file matches the experiment parameters. + * + * We do this by using the scanner to get the node and output portions of the file as they + * are separated by 3 tab characters. Every number is replaced by a single known character, + * and the length of the string with the new characters is compared with that of a string + * where the new known character has been removed, yielding the total number of values. + * + */ + FileReader fr; + try { + fr = new FileReader(file); + } catch (FileNotFoundException e) { + e.printStackTrace(); + return; + } + Scanner in = new Scanner(fr); + in.useDelimiter("\\t\\t\\t"); + String geneString = in.next().replaceAll("[0-9]+", "g"); + String outString = in.next().replaceAll("[0-9]+", "o"); + int geneCount = geneString.length() - geneString.replace("g", "").length(); + int outCount = outString.length() - outString.replace("o", "").length(); + in.close(); + + + // if the acquired values match the current parameters, apply them to the chromosome + if ((geneCount == resources.nodes() * (resources.arity() + 1)) + && outCount == resources.outputs()) { + // prepare a new scanner + try { + fr = new FileReader(file); + } catch (FileNotFoundException e) { + e.printStackTrace(); + return; + } + in = new Scanner(fr); + + int gene; + Connection newConnection; + Node changingNode; + // for all nodes, columns first + for (int c = 0; c < resources.columns(); c ++) { + for (int r = 0; r < resources.rows(); r ++) { + // store the changing node + changingNode = chromosome.getNode(r, c); + + // for every connection + for (int i = 0; i < resources.arity(); i ++) { + // get connection number from the .chr file + gene = in.nextInt(); + if (gene < resources.inputs()) { + // connection was an input + newConnection = chromosome.getInput(gene); + } else { + // connection was another node, calculate which from its number + newConnection = chromosome.getNode((gene - resources.inputs()) % resources.rows(), + (gene - resources.inputs()) / resources.rows()); + } + changingNode.setConnection(i, newConnection); + } + + // set the function, straight indexing should work - this is not entirely + // safe, but it is not viable to check for functionset compatibility + changingNode.setFunction(resources.getFunction(in.nextInt())); + } + } + + // outputs + for (int o = 0; o < resources.outputs(); o ++) { + gene = in.nextInt(); + if (gene < resources.inputs()) { + // connection was an input + newConnection = chromosome.getInput(gene); + } else { + // connection was another node, calculate which from its number + newConnection = chromosome.getNode((gene - resources.inputs()) % resources.rows(), + (gene - resources.inputs()) / resources.rows()); + } + chromosome.getOutput(o).setConnection(0, newConnection); + } + in.close(); + } + } + + /** + * Writes a chromosome into the specified .chr file. + * + * + * + * @param file + * @param chromosome + */ + public static void save(File file, Chromosome chromosome) { + + } + +} diff --git a/src/jcgp/backend/parser/FunctionParser.java b/src/jcgp/backend/parser/FunctionParser.java new file mode 100644 index 0000000..64a095c --- /dev/null +++ b/src/jcgp/backend/parser/FunctionParser.java @@ -0,0 +1,58 @@ +package jcgp.backend.parser; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.util.Scanner; + +import jcgp.backend.function.FunctionSet; +import jcgp.backend.modules.problem.Problem; + +public class FunctionParser { + +private FunctionSet functionSet; + + private FunctionParser(Problem problem) { + this.functionSet = problem.getFunctionSet(); + } + + public static void parseFunctions(File file, Problem problem) { + FunctionParser pp = new FunctionParser(problem); + + FileReader fr; + try { + fr = new FileReader(file); + } catch (FileNotFoundException e) { + e.printStackTrace(); + return; + } + + Scanner in = new Scanner(fr); + + while (in.hasNextLine()) { + String line = in.nextLine(); + if (line.substring(line.length() - 1).matches("[0-9]")) { + pp.parseAndSet(line.split("[^0-9]+")); + } + } + + in.close(); + } + + private void parseAndSet(String[] splitString) { +// System.out.println("new line"); +// for (int i= 0; i < splitString.length; i++) { +// System.out.println(i + ": " + splitString[i]); +// } + int functionIndex = Integer.parseInt(splitString[splitString.length - 1]); + System.out.println("index: " + functionIndex); + if (Integer.parseInt(splitString[0]) != 0) { + System.out.println("enabling: " + functionSet.getFunction(functionIndex).getName()); + functionSet.enableFunction(functionIndex); + } else { + System.out.println("disabling: " + functionSet.getFunction(functionIndex).getName()); + functionSet.disableFunction(functionIndex); + } + + } +} diff --git a/src/jcgp/backend/parser/ParameterParser.java b/src/jcgp/backend/parser/ParameterParser.java new file mode 100644 index 0000000..473b632 --- /dev/null +++ b/src/jcgp/backend/parser/ParameterParser.java @@ -0,0 +1,76 @@ +package jcgp.backend.parser; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.util.Scanner; +import jcgp.backend.resources.ModifiableResources; + +public class ParameterParser { + + private ModifiableResources resources; + + private ParameterParser(ModifiableResources resources) { + this.resources = resources; + } + + public static void parseParameters(File file, ModifiableResources resources) { + ParameterParser pp = new ParameterParser(resources); + + FileReader fr; + try { + fr = new FileReader(file); + } catch (FileNotFoundException e) { + e.printStackTrace(); + return; + } + + Scanner in = new Scanner(fr); + + while (in.hasNextLine()) { + pp.parseAndSet(in.nextLine().split("( |\t)+")); + } + + in.close(); + } + + private void parseAndSet(String[] splitString) { + switch (splitString[1]) { + + case "population_size": + resources.setPopulationSize(Integer.parseInt(splitString[0])); + break; + + case "num_generations": + resources.setGenerations(Integer.parseInt(splitString[0])); + break; + + case "num_runs_total": + resources.setRuns(Integer.parseInt(splitString[0])); + break; + + case "num_rows": + resources.setRows(Integer.parseInt(splitString[0])); + break; + + case "num_cols": + resources.setColumns(Integer.parseInt(splitString[0])); + break; + + case "levels_back": + resources.setLevelsBack(Integer.parseInt(splitString[0])); + break; + + case "report_interval": + resources.setReportInterval(Integer.parseInt(splitString[0])); + break; + + case "global_seed": + resources.setSeed(Integer.parseInt(splitString[0])); + break; + + default: + break; + } + } +} diff --git a/src/jcgp/backend/parser/TestCaseParser.java b/src/jcgp/backend/parser/TestCaseParser.java new file mode 100644 index 0000000..c997177 --- /dev/null +++ b/src/jcgp/backend/parser/TestCaseParser.java @@ -0,0 +1,13 @@ +package jcgp.backend.parser; + +import java.io.File; + +import jcgp.backend.modules.problem.TestCaseProblem; + +public class TestCaseParser { + + public static void parse(File file, TestCaseProblem<?> problem) { + + } + +} diff --git a/src/jcgp/backend/population/Population.java b/src/jcgp/backend/population/Population.java index a850595..1bbdc54 100644 --- a/src/jcgp/backend/population/Population.java +++ b/src/jcgp/backend/population/Population.java @@ -98,5 +98,4 @@ public class Population { public int getFittestIndex() { return fittest; } - } diff --git a/src/jcgp/backend/resources/ModifiableResources.java b/src/jcgp/backend/resources/ModifiableResources.java index 689f846..3841963 100644 --- a/src/jcgp/backend/resources/ModifiableResources.java +++ b/src/jcgp/backend/resources/ModifiableResources.java @@ -19,6 +19,10 @@ public class ModifiableResources extends Resources { super(); } + public void setValues(String filePath) { + + } + /** * @param rows the rows to set */ @@ -106,8 +110,8 @@ public class ModifiableResources extends Resources { /** * @param report the report to set */ - public void setReport(int report) { - this.report.set(report); + public void setReportInterval(int report) { + this.reportInterval.set(report); } /** @@ -197,10 +201,10 @@ public class ModifiableResources extends Resources { /** * @return the report */ - public IntegerParameter getReportParameter() { - return report; + public IntegerParameter getReportIntervalParameter() { + return reportInterval; } - + public void setFunctionSet(FunctionSet functionSet) { this.functionSet = functionSet; setArity(functionSet.getMaxArity()); diff --git a/src/jcgp/backend/resources/Resources.java b/src/jcgp/backend/resources/Resources.java index c83fa35..0bf1ee1 100644 --- a/src/jcgp/backend/resources/Resources.java +++ b/src/jcgp/backend/resources/Resources.java @@ -21,7 +21,7 @@ import jcgp.backend.resources.parameters.ParameterStatus; public class Resources { protected IntegerParameter rows, columns, inputs, outputs, populationSize, levelsBack, currentGeneration, generations, currentRun, runs, - arity, seed, report; + arity, seed, reportInterval; protected Random numberGenerator = new Random(); protected FunctionSet functionSet; @@ -124,10 +124,10 @@ public class Resources { } /** - * @return the report + * @return the report interval */ - public int report() { - return report.get(); + public int reportInterval() { + return reportInterval.get(); } private void createBaseParameters() { @@ -273,7 +273,7 @@ public class Resources { }); numberGenerator.setSeed(seed.get()); - report = new IntegerParameter(1, "Report", false, false) { + reportInterval = new IntegerParameter(1, "Report interval", false, false) { @Override public void validate(Number newValue) { if (newValue.intValue() > generations.get()) { @@ -325,8 +325,8 @@ public class Resources { * These are affected by parameter report */ public void reportln(String s) { - if (report.get() > 0) { - if (currentGeneration.get() % report.get() == 0) { + if (reportInterval.get() > 0) { + if (currentGeneration.get() % reportInterval.get() == 0) { System.out.println(s); if (console != null) { console.println(s); @@ -336,8 +336,8 @@ public class Resources { } public void report(String s) { - if (report.get() > 0) { - if (currentGeneration.get() % report.get() == 0) { + if (reportInterval.get() > 0) { + if (currentGeneration.get() % reportInterval.get() == 0) { System.out.print(s); if (console != null) { console.print(s); diff --git a/src/jcgp/backend/tests/ChromosomeTests.java b/src/jcgp/backend/tests/ChromosomeTests.java index 07326a7..36278ba 100644 --- a/src/jcgp/backend/tests/ChromosomeTests.java +++ b/src/jcgp/backend/tests/ChromosomeTests.java @@ -2,7 +2,7 @@ package jcgp.backend.tests; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; -import jcgp.backend.function.IntegerArithmetic; +import jcgp.backend.function.DoubleArithmetic; import jcgp.backend.population.Chromosome; import jcgp.backend.population.Connection; import jcgp.backend.population.Input; @@ -46,7 +46,7 @@ public class ChromosomeTests { @BeforeClass public static void setUpBeforeClass() { resources = new ModifiableResources(); - resources.setFunctionSet(new IntegerArithmetic()); + resources.setFunctionSet(new DoubleArithmetic()); } @Before diff --git a/src/jcgp/backend/tests/NodeTests.java b/src/jcgp/backend/tests/NodeTests.java index 0e08d92..c9f247a 100644 --- a/src/jcgp/backend/tests/NodeTests.java +++ b/src/jcgp/backend/tests/NodeTests.java @@ -3,7 +3,7 @@ package jcgp.backend.tests; import static org.junit.Assert.assertTrue; import jcgp.backend.exceptions.InvalidArgumentsException; import jcgp.backend.function.Function; -import jcgp.backend.function.IntegerArithmetic; +import jcgp.backend.function.DoubleArithmetic; import jcgp.backend.population.Chromosome; import jcgp.backend.population.Connection; import jcgp.backend.population.Node; @@ -41,7 +41,7 @@ public class NodeTests { public static void setUpBeforeClass() { resources = new ModifiableResources(); - resources.setFunctionSet(new IntegerArithmetic()); + resources.setFunctionSet(new DoubleArithmetic()); chromosome = new Chromosome(resources); } @@ -49,7 +49,7 @@ public class NodeTests { public void setUp() throws Exception { node = new Node(chromosome, 0, 0, resources.arity()); // make node with anonymous addition function and hard-coded value connections - node.initialise(new IntegerArithmetic.Addition(), + node.initialise(new DoubleArithmetic.Addition(), new Connection[]{new Connection() { @Override @@ -113,7 +113,7 @@ public class NodeTests { ((int) node.getValue()) == arg1 + arg2); // put in a different function, check the output has changed appropriately - node.setFunction(new IntegerArithmetic.Subtraction()); + node.setFunction(new DoubleArithmetic.Subtraction()); assertTrue("Node did not return expected value (difference of arguments).", ((Integer) node.getValue()) == arg1 - arg2); diff --git a/src/jcgp/backend/tests/OutputTests.java b/src/jcgp/backend/tests/OutputTests.java index a331f2d..95b7fc7 100644 --- a/src/jcgp/backend/tests/OutputTests.java +++ b/src/jcgp/backend/tests/OutputTests.java @@ -1,7 +1,7 @@ package jcgp.backend.tests; import static org.junit.Assert.assertTrue; -import jcgp.backend.function.IntegerArithmetic; +import jcgp.backend.function.DoubleArithmetic; import jcgp.backend.population.Chromosome; import jcgp.backend.population.Connection; import jcgp.backend.population.Output; @@ -35,7 +35,7 @@ public class OutputTests { @BeforeClass public static void setUpBeforeClass() { resources = new ModifiableResources(); - resources.setFunctionSet(new IntegerArithmetic()); + resources.setFunctionSet(new DoubleArithmetic()); chromosome = new Chromosome(resources); } diff --git a/src/jcgp/backend/tests/PopulationTests.java b/src/jcgp/backend/tests/PopulationTests.java index fb8ced4..fca9c4f 100644 --- a/src/jcgp/backend/tests/PopulationTests.java +++ b/src/jcgp/backend/tests/PopulationTests.java @@ -1,7 +1,7 @@ package jcgp.backend.tests; import static org.junit.Assert.assertTrue; -import jcgp.backend.function.IntegerArithmetic; +import jcgp.backend.function.DoubleArithmetic; import jcgp.backend.population.Chromosome; import jcgp.backend.population.Population; import jcgp.backend.resources.ModifiableResources; @@ -32,7 +32,7 @@ public class PopulationTests { @BeforeClass public static void setUpBeforeClass() throws Exception { resources = new ModifiableResources(); - resources.setFunctionSet(new IntegerArithmetic()); + resources.setFunctionSet(new DoubleArithmetic()); } @Before diff --git a/src/jcgp/gui/GUI.java b/src/jcgp/gui/GUI.java index e7a4a23..91c72e6 100644 --- a/src/jcgp/gui/GUI.java +++ b/src/jcgp/gui/GUI.java @@ -40,6 +40,8 @@ public class GUI extends Application { private final JCGP jcgp; + private Stage stage; + private final FunctionSelector functionSelector; private PopulationPane populationPane; @@ -108,7 +110,7 @@ public class GUI extends Application { public void start(Stage primaryStage) throws Exception { console = new GUIConsole(); jcgp.setConsole(console); - + stage = primaryStage; /* * Instantiate the various GUI elements here. * @@ -181,15 +183,20 @@ public class GUI extends Application { public void reset() { if (!running && settingsPane.areParametersValid()) { + setEvaluating(false); settingsPane.applyParameters(); jcgp.reset(); - populationPane.remakeTabs(); - settingsPane.revalidateParameters(); - settingsPane.updateControls(false, jcgp.isFinished()); - console.flush(); + reDraw(); } } + public void reDraw() { + populationPane.remakeTabs(); + settingsPane.revalidateParameters(); + settingsPane.updateControls(false, jcgp.isFinished()); + console.flush(); + } + private void runningMode(boolean value) { if (value) { populationPane.unlockOutputs(); @@ -234,4 +241,8 @@ public class GUI extends Application { public void setEvaluating(boolean value) { populationPane.setEvaluating(value); } + + public Stage getStage() { + return stage; + } } diff --git a/src/jcgp/gui/population/PopulationPane.java b/src/jcgp/gui/population/PopulationPane.java index 28b0ad9..5fa6067 100644 --- a/src/jcgp/gui/population/PopulationPane.java +++ b/src/jcgp/gui/population/PopulationPane.java @@ -38,19 +38,19 @@ public class PopulationPane extends TabPane { if (evaluating) { evaluateTestCase(currentTestCase); } - for (int i = 0; i < getChildrenUnmodifiable().size(); i++) { + for (int i = 0; i < getTabs().size(); i++) { ((ChromosomePane) getTabs().get(i).getContent()).updateGenes(); } } public void unlockOutputs() { - for (int i = 0; i < getChildrenUnmodifiable().size(); i++) { + for (int i = 0; i < getTabs().size(); i++) { ((ChromosomePane) getTabs().get(i).getContent()).unlockOutputs(); } } public void relockOutputs() { - for (int i = 0; i < getChildrenUnmodifiable().size(); i++) { + for (int i = 0; i < getTabs().size(); i++) { ((ChromosomePane) getTabs().get(i).getContent()).relockOutputs(); } } diff --git a/src/jcgp/gui/settings/SettingsPane.java b/src/jcgp/gui/settings/SettingsPane.java index 2ab9650..4e8c342 100644 --- a/src/jcgp/gui/settings/SettingsPane.java +++ b/src/jcgp/gui/settings/SettingsPane.java @@ -1,5 +1,6 @@ package jcgp.gui.settings; +import java.io.File; import java.util.ArrayList; import javafx.event.ActionEvent; @@ -16,6 +17,8 @@ import javafx.scene.layout.Priority; import javafx.scene.layout.VBox; import javafx.scene.text.Font; import javafx.scene.text.Text; +import javafx.stage.FileChooser; +import javafx.stage.FileChooser.ExtensionFilter; import jcgp.JCGP; import jcgp.backend.function.FunctionSet; import jcgp.backend.modules.es.EvolutionaryStrategy; @@ -31,6 +34,7 @@ public class SettingsPane extends AnchorPane { private VBox mainContainer; private VBox baseParameterPane, eaPane, mutatorPane, problemPane; + private VBox nodeFunctions; private Button runPause = new Button("Run"), step = new Button("Step"), reset = new Button("Reset"); private Button loadParameters = new Button("Load parameters"), loadChromosome = new Button("Load chromosome"), saveChromosome = new Button("Save chromosome"); @@ -103,7 +107,7 @@ public class SettingsPane extends AnchorPane { parameters.add(gp); parameters.add(GUIParameter.create(jcgp.getResources().getSeedParameter(), this)); - parameters.add(GUIParameter.create(jcgp.getResources().getReportParameter(), this)); + parameters.add(GUIParameter.create(jcgp.getResources().getReportIntervalParameter(), this)); baseParameterPane.getChildren().addAll(parameters); mainContainer.getChildren().add(baseParameterPane); @@ -201,10 +205,10 @@ public class SettingsPane extends AnchorPane { testCaseTable = new TestCaseTable((TestCaseProblem<Object>) jcgp.getProblem(), gui); } - final VBox nodeFunctions = new VBox(); + nodeFunctions = new VBox(); nodeFunctions.setSpacing(2); nodeFunctions.setPadding(new Insets(0, 0, 4, 0)); - refreshFunctions(jcgp.getResources().getFunctionSet(), nodeFunctions, gui); + refreshFunctions(); problemCBox.setOnAction(new EventHandler<ActionEvent>() { @Override @@ -215,7 +219,7 @@ public class SettingsPane extends AnchorPane { } testCaseTable.close(); gui.setEvaluating(false); - refreshFunctions(jcgp.getProblem().getFunctionSet(), nodeFunctions, gui); + refreshFunctions(); showTestCaseContainer.getChildren().clear(); if (jcgp.getProblem() instanceof TestCaseProblem) { showTestCaseContainer.getChildren().add(showTestCaseButton); @@ -284,14 +288,31 @@ public class SettingsPane extends AnchorPane { loadParameters.setOnAction(new EventHandler<ActionEvent>() { @Override public void handle(ActionEvent event) { - //gui.runPause(); + FileChooser fc = new FileChooser(); + fc.setTitle("Open .par file..."); + fc.getExtensionFilters().add(new ExtensionFilter("CGP parameter files", "*.par")); + fc.getExtensionFilters().add(new ExtensionFilter("All files", "*.*")); + File parFile = fc.showOpenDialog(gui.getStage()); + if (parFile != null) { + gui.getExperiment().loadParameters(parFile); + } + gui.reDraw(); + refreshFunctions(); } }); loadChromosome.setOnAction(new EventHandler<ActionEvent>() { @Override public void handle(ActionEvent event) { - //gui.step(); + FileChooser fc = new FileChooser(); + fc.setTitle("Open .chr file..."); + fc.getExtensionFilters().add(new ExtensionFilter("CGP chromosome files", "*.chr")); + fc.getExtensionFilters().add(new ExtensionFilter("All files", "*.*")); + File chrFile = fc.showOpenDialog(gui.getStage()); + if (chrFile != null) { + gui.getExperiment().loadChromosome(chrFile); + } + gui.reDraw(); } }); saveChromosome.setOnAction(new EventHandler<ActionEvent>() { @@ -331,31 +352,28 @@ public class SettingsPane extends AnchorPane { /** * This method handles a problem type change by updating the list of allowed * node functions. - * - * @param functionSet - * @param container - * @param gui */ - private void refreshFunctions(final FunctionSet functionSet, VBox container, final GUI gui) { - container.getChildren().clear(); + private void refreshFunctions() { + nodeFunctions.getChildren().clear(); CheckBox cb; - for (int i = 0; i < functionSet.getTotalFunctionCount(); i++) { - cb = new CheckBox(functionSet.getFunction(i).getName()); + final FunctionSet fs = gui.getExperiment().getResources().getFunctionSet(); + for (int i = 0; i < fs.getTotalFunctionCount(); i++) { + cb = new CheckBox(fs.getFunction(i).getName()); cb.setId(String.valueOf(i)); - cb.setSelected(functionSet.isEnabled(functionSet.getFunction(i))); + cb.setSelected(fs.isEnabled(fs.getFunction(i))); final int index = i; cb.setOnAction(new EventHandler<ActionEvent>() { @Override public void handle(ActionEvent event) { if (((CheckBox) event.getSource()).isSelected()) { - functionSet.enableFunction(index); + fs.enableFunction(index); } else { - functionSet.disableFunction(index); + fs.disableFunction(index); } gui.updateFunctionSelector(); } }); - container.getChildren().add(cb); + nodeFunctions.getChildren().add(cb); gui.updateFunctionSelector(); } @@ -436,6 +454,11 @@ public class SettingsPane extends AnchorPane { step.setDisable(running || finished); reset.setDisable(running); + loadParameters.setDisable(running); + loadChromosome.setDisable(running); + saveChromosome.setDisable(running); + + testCaseTable.getTable().setDisable(running); } diff --git a/src/jcgp/gui/settings/parameters/GUIParameter.java b/src/jcgp/gui/settings/parameters/GUIParameter.java index a8a8c4a..159e709 100644 --- a/src/jcgp/gui/settings/parameters/GUIParameter.java +++ b/src/jcgp/gui/settings/parameters/GUIParameter.java @@ -86,7 +86,7 @@ public abstract class GUIParameter<T> extends HBox { // the tooltip is the hover-over label containing status information, when appropriate tooltip = new Tooltip(); - tooltip.setStyle("-fx-background-color: white; -fx-border-color: black; .page-corner {-fx-background-color: transparent;}"); + tooltip.setStyle("-fx-background-color: white; -fx-border-color: black;"); tooltip.setSkin(null); valueControl = makeControl(); diff --git a/src/parameters.par b/src/parameters.par new file mode 100644 index 0000000..bf38c11 --- /dev/null +++ b/src/parameters.par @@ -0,0 +1,32 @@ +5 population_size +1.0 per_cent_mutate +10000 num_generations +10 num_runs_total +1 num_rows +100 num_cols +100 levels_back +1 progress_report +1000 report_interval +173156789 global_seed +0 run_from_chrom +0 shrink_phenotype +0 1 modulus-0 +0 1 sqrt-1 +0 1 reciprocal-2 +0 1 sin-3 +0 1 cos-4 +0 1 tan-5 +0 1 exp-6 +0 1 sinh-7 +0 1 cosh-8 +0 1 tanh-9 +0 1 nat-log-10 +0 1 logbase10-11 +0 2 sin(a+b)-12 +0 2 cos(a+b)-13 +0 2 hypoteneuse-14 +0 2 power-15 +1 2 addition-16 +1 2 subtraction-17 +1 2 multiplication-18 +1 2 division-19
\ No newline at end of file |