3 files changed, 20 insertions, 53 deletions

diff --git a/src/jcgp/backend/population/Chromosome.java b/src/jcgp/backend/population/Chromosome.java
index b99b817..0dfa801 100644
--- a/src/jcgp/backend/population/Chromosome.java
+++ b/src/jcgp/backend/population/Chromosome.java
@@ -159,7 +159,8 @@ public class Chromosome implements Comparable<Chromosome> {
 	 * this instance. In practice, this iterates through the
 	 * entire chromosome making equivalent connections and
 	 * setting functions to the same values as those in the
-	 * specified chromosome.
+	 * specified chromosome. It also sets the fitness of the
+	 * copy to the same value as the original.
 	 * <br>
 	 * It is assumed that both chromosomes have the same 
 	 * topology; while this method will still run if that is not
@@ -205,6 +206,9 @@ public class Chromosome implements Comparable<Chromosome> {
 				System.out.println("Warning: Connection of subtype " + copyOutput.getClass().toString() + " is not explicitly handled by copy constructor.");
 			}
 		}
+		
+		// copy fitness as well
+		this.fitness = clone.getFitness();
 	}
 
 	/**
@@ -264,7 +268,6 @@ public class Chromosome implements Comparable<Chromosome> {
 	 * number of inputs exactly, an exception is thrown.
 	 * 
 	 * @param values the values the input should take.
-	 * @throws ParameterMismatchException if the wrong number of values is received.
 	 */
 	public void setInputs(Object ... values) {
 		// if the values provided don't match the specified number of inputs, the user should be warned
diff --git a/src/jcgp/backend/population/MutableElement.java b/src/jcgp/backend/population/MutableElement.java
index 33f3890..5782a99 100644
--- a/src/jcgp/backend/population/MutableElement.java
+++ b/src/jcgp/backend/population/MutableElement.java
@@ -44,7 +44,7 @@ public interface MutableElement {
 	 * <li>not reflexive: a.copyOf(a) returns false;</li>
 	 * <li>not transitive: if a.copyOf(b) is true and b.copyOf(c) is true, a.copyOf(c) is
 	 *    not necessarily true since it is possible that a == c.</li>
-	 * 
+	 * </ul>
 	 * @param element the mutable element to compare to.
 	 * @return true if {@code element} is a copy of this element.
 	 */
diff --git a/src/jcgp/backend/population/Population.java b/src/jcgp/backend/population/Population.java
index 5d549e9..70cfda8 100644
--- a/src/jcgp/backend/population/Population.java
+++ b/src/jcgp/backend/population/Population.java
@@ -3,6 +3,7 @@ package jcgp.backend.population;
 import java.util.Arrays;
 import java.util.Collections;
 
+import jcgp.backend.modules.problem.BestFitness;
 import jcgp.backend.resources.Resources;
 
 /**
@@ -19,16 +20,6 @@ import jcgp.backend.resources.Resources;
  * experiment's specified seed. If an entirely random population
  * is needed, {@code reinitialise()} should be used to randomise
  * all chromosomes without creating a new instance of {@code Population}.
- * <br><br>
- * By convention the population's chromosomes should always be sorted in
- * order of fitness, from worst to best. This cannot be done automatically
- * since a higher fitness value does not necessarily mean better fitness;
- * some problem types might instead interpret fitness 0 as a perfect solution.
- * Sorting the population is done easily using {@code sortAscending()} and
- * {@code sortDescending()}, and should be done by the problem type as appropriate.
- * It is <b>critical</b> to sort the population after it is evaluated as 
- * evolutionary strategies will obey the convention and assume the population
- * is sorted in order of fitness.
  * 
  * 
  * @author Eduardo Pedroni
@@ -75,7 +66,7 @@ public class Population {
 	 * @param index the chromosome to return.
 	 * @return the indexed chromosome.
 	 */
-	public Chromosome getChromosome(int index) {
+	public Chromosome get(int index) {
 		return chromosomes[index];
 	}
 	
@@ -112,46 +103,19 @@ public class Population {
 			chromosomes[c].reinitialiseConnections();
 		}
 	}
-	
-	/**
-	 * The fittest chromosome, by convention, is the last one
-	 * in the array. Problem evaluation methods are expected to
-	 * sort the population into ascending order of fitness, such
-	 * that the best chromosome is in the last position (size - 1).
-	 * This method assumes that the population is sorted as such
-	 * and returns the last chromosome in the array.
-	 * 
-	 * @return the fittest chromosome in the population.
-	 */
-	public Chromosome getFittest() {
-		return chromosomes[chromosomes.length - 1];
-	}
-	
-	/**
-	 * The fittest chromosome, by convention, is the last one
-	 * in the array. Problem evaluation methods are expected to
-	 * sort the population into ascending order of fitness, such
-	 * that the best chromosome is in the last position (size - 1).
-	 * This method assumes that the population is sorted as such
-	 * and returns the last index in the array.
-	 * 
-	 * @return the index of the fittest chromosome.
-	 */
-	public int getFittestIndex() {
-		return chromosomes.length - 1;
-	}
-
-	/**
-	 * Sort the population into ascending order of fitness.
-	 */
-	public void sortAscending() {
-		Arrays.sort(chromosomes);
-	}
-	
+		
 	/**
-	 * Sort the population into descending order of fitness.
+	 * Sorts the population in ascending order of fitness quality.
+	 * What this means is that the best fitness chromosome will be
+	 * in the last position, even though it might have the lowest
+	 * fitness value. Fitness orientation as specified in the resources
+	 * is respected.
 	 */
-	public void sortDescending() {
-		Arrays.sort(chromosomes, Collections.reverseOrder());
+	public void sort() {
+		if (resources.fitnessOrientation() == BestFitness.HIGH) {
+			Arrays.sort(chromosomes);
+		} else {
+			Arrays.sort(chromosomes, Collections.reverseOrder());
+		}
 	}
 }