/**************************************************************************************
Janne Koljonen
Vaasan yliopisto

Soft Computing

Geneettinen algoritmi, joka ratkaisee Onemax-ongelman.


**************************************************************************************/

public class BittiGA
{
	private int[][] population; // population[] : yksilöt, population[][] kromosomit, population[x][0] = fitness
	private double elitism; // 0-1
	private double mutationrate; // 0-1
	private int generation; // Current generation
	private int maxgenerations; // >0
	private int stopfitness; // Tavoitehyvyys

	// args: {populaation koko,sukupolvien määrä,mutaatioprosentti,tulostustapa}
	public static void main(String[] args)
	{
		System.out.println("Onemax");
		int pop=10; // Populaation koko
		int gen=10; // Simuloitavien sukupolvien määrä
		int tul=1; // Tulostustapa
		if(args.length>0) pop=Integer.parseInt(args[0]);
		if(args.length>1) gen=Integer.parseInt(args[1])-1;

		// Luodaan olio tästä luokasta
		BittiGA ga=new BittiGA(pop,1);
		ga.mutationrate=0.1;
		if(args.length>2) ga.mutationrate=Integer.parseInt(args[2])/100;
		if(args.length>3) tul=Integer.parseInt(args[3]);
		
		ga.simulate(tul,gen);

		System.exit(0);
	}

	// Muodostin: (population size, number of chromosomes)
	public BittiGA(int popu,int numofchrom)
	{
		elitism=0.5;
		maxgenerations=10;
		stopfitness=0;
		population=new int[popu][1+numofchrom];
		initialize();
		sort();
		if(popu<30) printPopulation();
		else printBest();
	}

	// Alustaa populaation
	public void initialize()
	{
		generation=1;
		for(int i2=0;i2<population.length;i2++)
		{
			for(int i1=1;i1<population[i2].length;i1++)
			{
				int x=1;
				population[i2][i1]=this.newCromosome();
			}
		}
	}

	// Arpoo uuden bittivektorin bitti kerrallaan
	private int newCromosome()
	{
		int x=1;
		int apu=0;
		for(int b=0;b<32;b++)
		{
			if(Math.random()>=0.5)
			{
				apu+=x;
			}
			x<<=1;
		}
		return apu;
	}

	// Ajaa GA:ta sukupolvi kerrallaan
	public void simulate(int tulostus, int generations)
	{
		maxgenerations=generations;
		generation=1;
		simulate(tulostus);
	}

	// Ajaa yhden GA-sukupolven
	public void simulate(int tulostus)
	{
		if(tulostus==0)
		{
			while(generation<=maxgenerations && population[0][0]>stopfitness)
			{
				nextGeneration();
			}
		}
		else if(tulostus==1)
		{
			while(generation<=maxgenerations && population[0][0]>stopfitness)
			{
				nextGeneration();
				printBest();
			}
		}
		else
		{
			while(generation<=maxgenerations && population[0][0]>stopfitness)
			{
				nextGeneration();
				printPopulation();
			}
		}
		System.out.println("Simulation over!");
		printBest();
	}

	// Arpoo risteytykseen vanhemmat ja kutsuu crossover-metodia
	public void nextGeneration()
	{
		int x1=0;
		int x2=0;
		for(int i2=(int)(elitism*population.length);i2<population.length;i2++) // Elitismin jälkeen uusia yksilöitä
		{
			for(int i1=1;i1<population[i2].length;i1++) // Kromosomeittain risteytys
			{
				do // Arvotaan vanhemmat
				{
					x1=(int)(Math.random()*Math.random()*elitism*population.length);
					x2=(int)(Math.random()*elitism*population.length);
				}
				while(population[x1][i1]==population[x2][i1]); // Vältetään risteytystä itsensä kanssa
				this.crossover(x1,x2,i2,i1);
				if(population[x1][i1]==population[i2][i1] || population[x2][i1]==population[i2][i1])
				{
					// Ei hyväksytä klooneja
					population[i2][i1]=this.newCromosome(); // Aivan uusi kromosomi
				}
			}
		}
		this.sort();
		generation++;
	}

	// Laskee hyvyysarvot koko populaatiolle
	private void fitnesses()
	{
		Hamming h=new Hamming();
		for(int i2=0;i2<population.length;i2++)
		{
			population[i2][0]=32-h.hamming(population[i2][1],0);
		}
	}

	// Järjestää yksilöt paremmuusjärjestykseen, käyttää itse tehtyä InsertionSort-luokkaa
	public void sort()
	{
		this.fitnesses();
		InsertionSort.sort(population,0);
	}

	// Risteyttää kromosomit populaation indekseistä population[x1][crom] ja population[x2][crom].
	// Uusi kromosomi kohtaan population[xnew][crom]
	public void crossover(int x1,int x2,int xnew,int crom)
	{
		int x=1;
		population[xnew][crom]=0; // Asetetaan hyvyysarvo nollaksi

		// Käydään kromosomi läpi bitti kerrallaan, uniform crossover
		for(int b=0;b<32;b++)
		{
			if(Math.random()>=0.5) // Kummasta vanhemmasta
			{
				if(Math.random()>=mutationrate) // Tehdäänkö mutaatioa
				{
					population[xnew][crom]+=population[x1][crom]&x;
				}
				else if(population[x1][crom]&x==0) // Tehdään mutaatio
				{
					population[xnew][crom]+=x;
				}
			}
			else // Toisesta vanhemmasta
			{
				if(Math.random()>=mutationrate)
				{
					population[xnew][crom]+=population[x2][crom]&x;
				}
				else if(population[x2][crom]&x==0)
				{
					population[xnew][crom]+=x;
				}
			}
			x<<=1;
		}
	}

	// Tulostaa koko populaation
	public void printPopulation()
	{
		System.out.println("Fitnesses and values on generation "+generation);
		for(int i2=0;i2<population.length;i2++)
		{
			System.out.print("Object "+i2+"\t Fitness="+population[i2][0]);
			for(int i1=1;i1<population[i2].length;i1++)
			{
				System.out.print("\tChromosome "+i1+"="+population[i2][i1]);
			}
			System.out.println();
		}
		System.out.println();
	}

	// Tulostaa parhaan yksilön
	public void printBest()
	{
		System.out.println("Best fitness and value on generation "+generation);
		System.out.print("Fitness="+population[0][0]);
		for(int i1=1;i1<population[0].length;i1++)
		{
			System.out.print("\tChromosome "+i1+"="+population[0][i1]);
		}
		System.out.println();
	}
}