Fix the Hibernate4 issues (#1106)

* Binary genetic algorithm

* Fix the junit tests conflict

core-java/src/main/java/com/baeldung/algorithms/RunAlgorithm.java

@@ -3,28 +3,34 @@ package com.baeldung.algorithms;
 import java.util.Scanner;
 
 import com.baeldung.algorithms.annealing.SimulatedAnnealing;
+import com.baeldung.algorithms.ga.binary.SimpleGeneticAlgorithm;
 import com.baeldung.algorithms.slope_one.SlopeOne;
 
 public class RunAlgorithm {
 
-    public static void main(String[] args) {
-        Scanner in = new Scanner(System.in);
-        System.out.println("Run algorithm:");
-        System.out.println("1 - Simulated Annealing");
-        System.out.println("2 - Slope One");
-        int decision = in.nextInt();
-        switch (decision) {
-        case 1:
-            System.out.println("Optimized distance for travel: " + SimulatedAnnealing.simulateAnnealing(10, 10000, 0.9995));
-            break;
-        case 2:
-            SlopeOne.slopeOne(3);
-            break;
-        default:
-            System.out.println("Unknown option");
-            break;
-        }
-        in.close();
-    }
+	public static void main(String[] args) {
+		Scanner in = new Scanner(System.in);
+		System.out.println("Run algorithm:");
+		System.out.println("1 - Simulated Annealing");
+		System.out.println("2 - Slope One");
+		System.out.println("3 - Simple Genetic Algorithm");
+		int decision = in.nextInt();
+		switch (decision) {
+		case 1:
+			System.out.println(
+					"Optimized distance for travel: " + SimulatedAnnealing.simulateAnnealing(10, 10000, 0.9995));
+			break;
+		case 2:
+			SlopeOne.slopeOne(3);
+			break;
+		case 3:
+			SimpleGeneticAlgorithm.runAlgorithm(50, "1011000100000100010000100000100111001000000100000100000000001111");
+			break;
+		default:
+			System.out.println("Unknown option");
+			break;
+		}
+		in.close();
+	}
 
 }

core-java/src/main/java/com/baeldung/algorithms/ga/binary/Individual.java

@@ -0,0 +1,44 @@
+package com.baeldung.algorithms.ga.binary;
+
+import lombok.Data;
+
+@Data
+public class Individual {
+
+	protected int defaultGeneLength = 64;
+	private byte[] genes = new byte[defaultGeneLength];
+	private int fitness = 0;
+
+	public Individual() {
+		for (int i = 0; i < genes.length; i++) {
+			byte gene = (byte) Math.round(Math.random());
+			genes[i] = gene;
+		}
+	}
+
+	protected byte getSingleGene(int index) {
+		return genes[index];
+	}
+
+	protected void setSingleGene(int index, byte value) {
+		genes[index] = value;
+		fitness = 0;
+	}
+
+	public int getFitness() {
+		if (fitness == 0) {
+			fitness = SimpleGeneticAlgorithm.getFitness(this);
+		}
+		return fitness;
+	}
+
+	@Override
+	public String toString() {
+		String geneString = "";
+		for (int i = 0; i < genes.length; i++) {
+			geneString += getSingleGene(i);
+		}
+		return geneString;
+	}
+
+}

core-java/src/main/java/com/baeldung/algorithms/ga/binary/Population.java

@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.ga.binary;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.Data;
+
+@Data
+public class Population {
+
+	private List<Individual> individuals;
+
+	public Population(int size, boolean createNew) {
+		individuals = new ArrayList<>();
+		if (createNew) {
+			createNewPopulation(size);
+		}
+	}
+
+	protected Individual getIndividual(int index) {
+		return individuals.get(index);
+	}
+
+	protected Individual getFittest() {
+		Individual fittest = individuals.get(0);
+		for (int i = 0; i < individuals.size(); i++) {
+			if (fittest.getFitness() <= getIndividual(i).getFitness()) {
+				fittest = getIndividual(i);
+			}
+		}
+		return fittest;
+	}
+
+	private void createNewPopulation(int size) {
+		for (int i = 0; i < size; i++) {
+			Individual newIndividual = new Individual();
+			individuals.add(i, newIndividual);
+		}
+	}
+}

core-java/src/main/java/com/baeldung/algorithms/ga/binary/SimpleGeneticAlgorithm.java

@@ -0,0 +1,119 @@
+package com.baeldung.algorithms.ga.binary;
+
+import lombok.Data;
+
+@Data
+public class SimpleGeneticAlgorithm {
+
+	private static final double uniformRate = 0.5;
+	private static final double mutationRate = 0.025;
+	private static final int tournamentSize = 5;
+	private static final boolean elitism = true;
+	private static byte[] solution = new byte[64];
+
+	public static boolean runAlgorithm(int populationSize, String solution) {
+		if (solution.length() != SimpleGeneticAlgorithm.solution.length) {
+			throw new RuntimeException(
+					"The solution needs to have " + SimpleGeneticAlgorithm.solution.length + " bytes");
+		}
+		SimpleGeneticAlgorithm.setSolution(solution);
+		Population myPop = new Population(populationSize, true);
+
+		int generationCount = 1;
+		while (myPop.getFittest().getFitness() < SimpleGeneticAlgorithm.getMaxFitness()) {
+			System.out.println(
+					"Generation: " + generationCount + " Correct genes found: " + myPop.getFittest().getFitness());
+			myPop = SimpleGeneticAlgorithm.evolvePopulation(myPop);
+			generationCount++;
+		}
+		System.out.println("Solution found!");
+		System.out.println("Generation: " + generationCount);
+		System.out.println("Genes: ");
+		System.out.println(myPop.getFittest());
+		return true;
+	}
+
+	public static Population evolvePopulation(Population pop) {
+		int elitismOffset;
+		Population newPopulation = new Population(pop.getIndividuals().size(), false);
+
+		if (elitism) {
+			newPopulation.getIndividuals().add(0, pop.getFittest());
+			elitismOffset = 1;
+		} else {
+			elitismOffset = 0;
+		}
+
+		for (int i = elitismOffset; i < pop.getIndividuals().size(); i++) {
+			Individual indiv1 = tournamentSelection(pop);
+			Individual indiv2 = tournamentSelection(pop);
+			Individual newIndiv = crossover(indiv1, indiv2);
+			newPopulation.getIndividuals().add(i, newIndiv);
+		}
+
+		for (int i = elitismOffset; i < newPopulation.getIndividuals().size(); i++) {
+			mutate(newPopulation.getIndividual(i));
+		}
+
+		return newPopulation;
+	}
+
+	private static Individual crossover(Individual indiv1, Individual indiv2) {
+		Individual newSol = new Individual();
+		for (int i = 0; i < newSol.getDefaultGeneLength(); i++) {
+			if (Math.random() <= uniformRate) {
+				newSol.setSingleGene(i, indiv1.getSingleGene(i));
+			} else {
+				newSol.setSingleGene(i, indiv2.getSingleGene(i));
+			}
+		}
+		return newSol;
+	}
+
+	private static void mutate(Individual indiv) {
+		for (int i = 0; i < indiv.getDefaultGeneLength(); i++) {
+			if (Math.random() <= mutationRate) {
+				byte gene = (byte) Math.round(Math.random());
+				indiv.setSingleGene(i, gene);
+			}
+		}
+	}
+
+	private static Individual tournamentSelection(Population pop) {
+		Population tournament = new Population(tournamentSize, false);
+		for (int i = 0; i < tournamentSize; i++) {
+			int randomId = (int) (Math.random() * pop.getIndividuals().size());
+			tournament.getIndividuals().add(i, pop.getIndividual(randomId));
+		}
+		Individual fittest = tournament.getFittest();
+		return fittest;
+	}
+
+	protected static int getFitness(Individual individual) {
+		int fitness = 0;
+		for (int i = 0; i < individual.getDefaultGeneLength() && i < solution.length; i++) {
+			if (individual.getSingleGene(i) == solution[i]) {
+				fitness++;
+			}
+		}
+		return fitness;
+	}
+
+	protected static int getMaxFitness() {
+		int maxFitness = solution.length;
+		return maxFitness;
+	}
+
+	protected static void setSolution(String newSolution) {
+		solution = new byte[newSolution.length()];
+		for (int i = 0; i < newSolution.length(); i++) {
+			String character = newSolution.substring(i, i + 1);
+			if (character.contains("0") || character.contains("1")) {
+				solution[i] = Byte.parseByte(character);
+			} else {
+				solution[i] = 0;
+			}
+		}
+	}
+
+}