#include "genocop.h"/* Cumulative probability on crossover *//* Random probability on mutation       *//* NO multiple hits per agent possible  *//********************************************************************************//*                                                                              *//*           FUNCTION NAME     :   optimization()                               *//*                                                                              *//*           SYNOPSIS          :   void optimization(X,x1,x2,fin_mat,rc,tot_eq) *//*                                                                              *//*           DESCRIPTION       :   This procedure initializes the population    *//*                                  with the values X passed from main, and     *//*                                  evaluates them.  After assigning weight     *//*                                  for each member of the populaiton, a group  *//*                                  of them are chosen to reproduce and a group *//*                                  is chosen to die.  Genetic operators are    *//*                                  applied and a new generation is produced    *//*                                  to replace the members that died.  This     *//*                                  cycle continues for the number of times,    *//*                                  user specifies in the input file            *//*                                                                              *//*           FUNCTIONS CALLED  :   assign_probab(),                             *//*                                 evaluate(),                                  *//*                                 find_cum_probab(),                           *//*                                 find_live_die(),                             *//*                                 find_parent(),                               *//*                                 ivector(),                                   *//*                                 matrix(),                                    *//*                                 oper1(),                                     *//*                                 oper2(),                                     *//*                                 oper3(),                                     *//*                                 oper4(),                                     *//*                                 oper5(),                                     *//*                                 oper6(),                                     *//*                                 print_matrix(),                              *//*                                 print_population(),                          *//*                                 sort(),                                      *//*                                 vector().                                    *//*                                                                              *//*           CALLING FUNCITONS :   main()                                       *//*                                                                              *//*                                                                              *//********************************************************************************/voidoptimization(X, x1, x2, fin_mat, rc, tot_eq, a1_b)    MATRIX          fin_mat;    VECTOR          X, a1_b;    IVECTOR         x1, x2;    INDEX           rc;    int             tot_eq;{    MATRIX          new_genera,		    /* Temporary storage for the new					     * generation */                    population,		    /* Population of x2 variables */                    ref_population,	    /* pop. of ref. vectors */                    print_pop, temp;    VECTOR          probab,		    /* Probability of agents to die					     * or live */		    ref_probab,             /* prob. dist. of ref pop */		                        cum_probab,		    /* Cumulative probability of					     * agents */                    t_vec, temp_vec;    IVECTOR         live, die;    unsigned long   generations;	    /* Total number of Generations */    unsigned long   count_gener = 1;	    /* counter : number of					     * generations */    unsigned long   peak_cnt;    int             P1, P2, P3, P4, P5, P6, P7,	/* # of parents for each op. */                    j1, j2, j3, j4, j5, j6, j7,	/* j vars */                    pop_size,		    /* Population size */                    MinMax,		    /* Min or Max problem : 0 or 1 */                    init_val,		    /* Single or multiple point init.					     * population? */                    P,			    /* Total number of agents chosen					     * to reproduce */                    oper,		    /**/                    B,			    /* Parm. for op. 3 - nonuniform					     * mutation */                    STEP,		    /* for op. 5 - simple					     * arithmetical xover */                    x2_vari = rc.c - 2,	    /**/                    first,		    /* Index of the parent to mutate */                    first_live,		    /* Index of the two parents for					     * xover parents */                    second_live, first_die, /* Index of the two parents for					     * xover death */                    second_die, tot,	    /* total number of chosen parents					     * not used */                    i, j, k, dup_count,	    /* replication count */                    nonlinear_check;	    /* NL check flag while moving */    float           Q,			    /* Probability of the best agent */                    A,			    /* Parm. for op. 4 - whole					     * arithmetical xover */                    Teval,		    /* Evaluation of the best agent */                    R_Teval,		    /* Evaluation of best ref. agent */                    TR_Teval, initial_val;  /* Initial value of the					     * population */    float           peak_val;    float           amove;		    /* const. used for moving */    int             x, y;    FLAG            same;    FLAG            _PROGEND;    float         **new;    char            response_char;    int             nlcflag = TRUE;	    /* flag for NL constraints */    float           p_x_z = 0.0;    int             amovecount = 0;    int             rindex = 0;		    /* random index */    float	    pr_x_z_replace=0.0;     /* prob. of repl. of x by Z */    int		    NI_NUMBER = 0;	    /* no. of NI constraints */    int		    NE_NUMBER = 0;	    /* no. of NE constraints */    float	    EPSILON=0.0;	    /* precision input */    int		    prob_dist_mode=0;       /* 0 for random, 1 for distrib.    					       for ref. pop. choice */    float	    temp_prob=0.0;    /*     * Reading from the file the population size, total number of     * generations, total number of times each of the 5 operators to be     * applied, probability of the best agent, minimization or maximization     * problem, the parameters for the operators     */    fscanf(input, "%d %lU %d %d %d %d %d %d %d", &pop_size, &generations, &P1, &P2, &P3, &P4, &P5, &P6, &P7);    fscanf(input, "%f ", &Q);    fscanf(input, "%d ", &MinMax);    fscanf(input, "%d ", &init_val);    fscanf(input, "%d ", &B);    fscanf(input, "%d ", &STEP);    fscanf(input, "%d ", &test_num);    fscanf(input, "%f ", &pr_x_z_replace);    fscanf(input, "%d ", &NI_NUMBER);    NE_NUMBER = 0;    EPSILON = 0.0;    fscanf(input, "%f ", &prob_dist_mode);            fclose(input);    fprintf(output, "\n\n");    fprintf(output, "Test case number           : %d\n", test_num);    fprintf(output, "Number of operators        : %d  %d  %d  %d  %d  %d  %d\n", P1, P2, P3, P4, P5, P6, P7);    fprintf(output, "Number of generations      : %lu\n", generations);    fprintf(output, "Population size            : %d\n", pop_size);    fprintf(output, "Parameter B                : %d\n", B);    fprintf(output, "Parameter Q                : %f\n", Q);    fprintf(output, "Max/Min                    : %d\n", MinMax);    fprintf(output, "Probability of replacement : %f\n", pr_x_z_replace);    fprintf(output, "Initialization mode        : %d\n", init_val);    fprintf(output, "Selection of refer. point  : %d\n", prob_dist_mode);    /* P is the total number of parents needed for applying all the operators */    P = P1 + P2 + P3 + P4 + P5 + P6 + P7;    if (P > pop_size)    {	printf("The total number of operators greater than population\n");	fprintf(output, "The total number of operators greater than population\n");	fclose(output);	exit(1);    }    peak_val = 0;    peak_cnt = 0;    /* Space allocation for all the vectors and matrices involved */    population = matrix(1, pop_size, 0, x2_vari + 1);    ref_population = matrix(1, pop_size, 0, x2_vari + 1);    print_pop = matrix(1, pop_size, 0, x2_vari + tot_eq + 1);    new_genera = matrix(1, pop_size, 0, x2_vari + 1);    temp = matrix(1, 2, 1, x2_vari);    probab = vector(1, pop_size);    ref_probab = vector(1, pop_size);    t_vec = vector(1, x2_vari);    temp_vec = vector(0, x2_vari+1);    cum_probab = vector(1, pop_size);    live = ivector(1, pop_size);    die = ivector(1, pop_size);    /*     * Initial population with all identical agents, whose values were got     * randomly - ditto for initial reference population     */    if (init_val == 1)    {	fprintf(output, "\n\nUSING SINGLE POINT INITIAL POPULATION...\n\n");	_PROGEND = initialize_x2(fin_mat, rc, x1, x2, tot_eq, X, a1_b, FALSE,					NI_NUMBER, NE_NUMBER, EPSILON);	for (j = 1; j <= pop_size; j++)	{	    for (i = 1; i <= x2_vari; i++)	    {		population[j][i] = X[x2[i]];		population[j][x2_vari + 1] = 0;	    }	    population[j][0] = evaluate(X);	}	fprintf(output, "\nThe initial point of the population is\n");	print_vector(X, 1, tot_eq + x2_vari);	_PROGEND = initialize_x2(fin_mat, rc, x1, x2, tot_eq, X, a1_b, TRUE,					NI_NUMBER, NE_NUMBER, EPSILON);	for (j = 1; j <= pop_size; j++)	{	    for (i = 1; i <= x2_vari; i++)	    {		ref_population[j][i] = X[x2[i]];		ref_population[j][x2_vari + 1] = 0;	    }	    ref_population[j][0] = evaluate(X);	}	fprintf(output, "\nThe initial point of the ref. population is\n");	print_vector(X, 1, tot_eq + x2_vari);    }    /* end of if init_val == 1 ...else starts below */    /*    ** MULTIPLE POINT INITIALIZATION FOR BOTH POPULATIONS    */    else    {	fprintf(output, "\n\nUSING MULTIPLE POINT INITIAL POPULATION...\n\n");	j = 1;	while (j <= pop_size)	{	    _PROGEND = initialize_x2(fin_mat, rc, x1, x2, tot_eq, X, a1_b,				     FALSE, NI_NUMBER, NE_NUMBER, EPSILON);	    if (_PROGEND == TRUE)	    {		for (i = 1; i <= x2_vari; i++)		{		    population[j][i] = X[x2[i]];		    population[j][x2_vari + 1] = 0;		}		population[j][0] = evaluate(X);		j++;		/*printf("Linear Gen. ok\n");*/	    } else	    {		printf("Vector is feasible w.r.t linear constraints.\nDo you wish to include/replicate this vector in the population? (y/n)");		fflush(stdin);		response_char = getchar();		fflush(stdin);		if (response_char == 'Y' || response_char == 'y')		{		    do		    {			printf("How many copies (min. 1, max. %d) :", pop_size -			       j + 1);			scanf("%d", &dup_count);			if ((dup_count < 1) || (dup_count > (pop_size - j + 1)))			    printf("\nInvalid entry.  Must be in the range 1 to %d\n",				   pop_size - j + 1);		    } while ((dup_count < 1) || (dup_count > (pop_size - j + 1)));		    for (k = 1; k <= dup_count; k++)		    {			for (i = 1; i <= x2_vari; i++)			{			    population[j][i] = X[x2[i]];			    population[j][x2_vari + 1] = 0;			}		    	population[j][0] = evaluate(X);			j++;		    }			    /* end of for dup_count.... */		}			    /* end of if response_char...... */	    }				    /* end of if					     * _PROGEND...else.............. */	}				    /* end of do loop for multiple					     * pt. */	/* Now for the reference pop. multiple init */	j = 1;	dup_count = 0;	while (j <= pop_size)	{	    _PROGEND = initialize_x2(fin_mat, rc, x1, x2, tot_eq, X, a1_b,				     TRUE, NI_NUMBER, NE_NUMBER, EPSILON);	    if (_PROGEND == TRUE)	    {		for (i = 1; i <= x2_vari; i++)		{		    ref_population[j][i] = X[x2[i]];		    ref_population[j][x2_vari + 1] = 0;		}	    	ref_population[j][0] = evaluate(X);		j++;	    } else 	    {		printf("Vector is feasible w.r.t all constraints.\nDo you wish to include/replicate this vector in the population? (y/n)");		fflush(stdin);		response_char = getchar();		fflush(stdin);		if (response_char == 'Y' || response_char == 'y')		{		    do		    {			printf("How many copies (min. 1, max. %d) :", pop_size - j + 1);			scanf("%d", &dup_count);			if ((dup_count < 1) || (dup_count > (pop_size - j + 1)))			    printf("\nInvalid entry.  Must be in the range 1 to %d\n",				   pop_size - j + 1);		    } while ((dup_count < 1) || (dup_count > (pop_size - j + 1)));		    for (k = 1; k <= dup_count; k++)		    {			for (i = 1; i <= x2_vari; i++)			{			    ref_population[j][i] = X[x2[i]];			    ref_population[j][x2_vari + 1] = 0;			}	    		ref_population[j][0] = evaluate(X);						j++;		    }			    /* end of for dup_count.... */		}			    /* end of if response_char...... */	    }				    /* end of if					     * _PROGEND...else.............. */	}				    /* end of while */    }					    /* end of if init_val block */