#define JOBS 12
#define TASKS 6

#define POP 20					// Number of individuals in population
#define M 3
#define CURRENT 0
#define MUTATIONS 1
#define OFFSPRING 2

int population[POP][JOBS];			// The current population
int variations[POP][JOBS];			// The mutations
int crossover[POP][JOBS];			// The offspring
int duration[JOBS][TASKS];

continuous Makespan;				// The objective function
continuous Ft[JOBS][TASKS];			// Finish time of task t of job j

double fitness[M][POP];				// Evaluation of fitness

#define ITERATIONS 10				// Number of generations

2lp_main()
{
	data();
	setup();

	initialize(population,fitness[CURRENT]);

	and(int it=0;it<ITERATIONS;it++) {
		generate_pool(); 					// New individuals
		survival_of_the_fittest();				// Natural selection
	}
                
	and(int p=0;p<POP;p++) 
		printf("fitness of %d is %f\n",p,fitness[CURRENT][p]);
}

data()
{
	duration =    {  10,3,6,7,23,6,
				8,5,10,10,10,4,
				5,24,8,9,1,7,
				5,5,25,3,8,9,
				9,3,35,4,3,1,
				23,3,9,10,4,1,
				1,32,6,7,3,6,
				18,5,10,10,10,4,
				5,14,8,9,11,7,
				25,5,5,3,8,9,
				9,3,5,24,3,1,
				3,13,19,10,4,1 };
}

find_next_random_sequence(int q[], int n)
{
int temp, rand;

	and(int i=0;i<n;i++) 
		q[i] = i;
	and(int i=0;i<n;i++) {
		rand = random()*n-i; 		// random integer 
								// between 0 and n-i-1
		temp = q[i+rand];
		q[i+rand] = q[i];
		q[i] = temp;
	} 
}

initialize(int pop[][JOBS],double fitness[])
{
	seed(1968);		// Prime pseudorandom number generator
	and(int k=0;k<POP;k++) {
		find_next_random_sequence(pop[k],JOBS);
		compute_fitness(pop[k],fitness[k]);
	} 
}

compute_fitness(int p[],double & fit)
{
	if not {   
		and(int jb=0;jb<JOBS-1;jb++)
			and(int tsk=0;tsk<TASKS;tsk++)
				Ft[p[jb]][tsk] + duration[p[jb+1]][tsk]
				<= Ft[p[jb+1]][tsk];
		min: Makespan;
		fit  = wp(Makespan);
	} 	
	then { 
		printf("Error\n");			// Every permutation is a
		exit();					// valid solution
	}
}

generate_pool()
{
	mutations(variations,fitness[MUTATIONS]);
	reproductions(crossover,fitness[OFFSPRING]);
}

mutations(int pool[][JOBS], double fitness[])
{
int s,t;
int temp;
 
	and(int p=0;p<POP;p++) {
		and(int k=0;k<JOBS;k++) 
			pool[p][k] = population[p][k];
		s = random()*JOBS;						// random elements
		t = random()*JOBS;						// in [0,...,JOBS-1]
		temp = pool[p][s];
		pool[p][s] = pool[p][t];
		pool[p][t] = temp;
		compute_fitness(pool[p],fitness[p]);
	} 
}

reproductions(int pool[][JOBS], double fitness[])
{
int s,top;
 
	and(int p=0;p<POP;p++) { 
		s = random()*POP;					// random from [0,...,POP-1]
		top = JOBS/2;
		and(int j=0;j<JOBS;j++)
			pool[p][j] = population[p][j];
		and(int j=0;j<JOBS;j++) {
			if and(int i=0;i<top;i++)
			pool[p][i] != population[s][j];
			then { 
				pool[p][top] = population[s][j];
				top = top+1;
			}
			if top == JOBS;
			then break;
		}
		compute_fitness(pool[p],fitness[p]);
	}
}

survival_of_the_fittest()
{
	select_from(MUTATIONS,variations);
	select_from(OFFSPRING,crossover);
}

select_from(int type, int pool[][JOBS])
{
double gauge;
int temp;

	and(int k=0;k<POP;k++) {				// Individual from new group
		gauge = fitness[type][k];				// Record its fitness
		temp = POP;
		and(int s=0;s<POP;s++)				// Individual from old group
			if gauge < fitness[CURRENT][s];	// Compare 
			then {						// Less fit individual found
				temp = s;						// Least fit individual so far
				gauge = fitness[CURRENT][s];	// Its fitness
			};
		if temp !=POP;					// Less fit individual has been found
		then {		// Place new individual in current population
			and(int t=0;t<JOBS;t++) 
				population[temp][t] = pool[k][t];
			fitness[CURRENT][temp] =fitness[type][k];
		}
	}
}

setup()
{
	and(int jb=0;jb<JOBS;jb++)
		and(int tsk=0;tsk<TASKS;tsk++)
			sigma(int s=0;s<=tsk;s++) duration[jb][s] 
			<= Ft[jb][tsk];
 
	and(int jb=0;jb<JOBS;jb++)
		and(int tsk=0;tsk<TASKS-1;tsk++)
			Ft[jb][tsk] + duration[jb][tsk+1]
			<= Ft[jb][tsk+1];
 
	and(int jb=0;jb<JOBS;jb++)
		Makespan >= Ft[jb][TASKS-1];
} 
 