evaluate.c

很好的一个约束遗传算法优化程序

    /*********** eval. and sort first generation *************************/
    /* Evaluate the best in ref_population and assign to R_Teval */
    
    for (i = 1; i <= pop_size; i++)
    {
	/*
	 * if (population[i][x2_vari+1] != 0) do not reevaluate if no changes
	 * were made
	 */
	{
	    if (tot_eq != 0)
	    {
		for (j = 1; j <= x2_vari + tot_eq; j++)
		    X[j] = 0.0;
		find_X(fin_mat, ref_population[i], X, x2_vari, tot_eq, x1, x2, a1_b);
	    } else
		for (j = 1; j <= x2_vari; j++)
		    X[j] = ref_population[i][j];
	    ref_population[i][0] = evaluate(X);
	}
    }
    sort(MinMax, ref_population, pop_size); R_Teval = ref_population[1][0];

    for (i = 1; i <= pop_size; i++)
    {
	/*
	 * if (population[i][x2_vari+1] != 0)
	 */
	{
	    if (tot_eq != 0)
	    {
		for (j = 1; j <= x2_vari + tot_eq; j++)
		    X[j] = 0.0;
		find_X(fin_mat, population[i], X, x2_vari, tot_eq, x1, x2, a1_b);
	    } else
		for (j = 1; j <= x2_vari; j++)
		    X[j] = population[i][j];
	    population[i][0] = evaluate(X);

	    /*
	     * keep moving from X to Y till we satisfy NL&L feasibility
	     * condition
	     */

	    rindex = 1;
	    /*(int) frange_ran(1.0, (float)pop_size); */
	    amove = 0.0;
	    amovecount = 0;
	    nonlinear_check = FALSE;
	    do
	    {
		amove = frange_ran(0.0, 1.0);
		for (j = 1; j < x2_vari + 1; j++)
		    temp_vec[j] = amove * ref_population[rindex][j] + (1 - amove) *
			population[i][j];
		nonlinear_check = nonlinear(temp_vec, NI_NUMBER, NE_NUMBER,
					EPSILON);
		amovecount++;
	    } while ((nonlinear_check == FALSE) && (amovecount < 100));
	    if (amovecount == 100)
	    {
		/*printf("Z = Y\n");*/
		for (j = 1; j < x2_vari + 1; j++)
		    temp_vec[j] = ref_population[rindex][j];
	    }
	    Teval = evaluate(temp_vec);
	    R_Teval = evaluate(ref_population[rindex]);
	    temp_vec[0] = Teval;  population[i][0] = Teval;
	    /* if eval(Z) > eval (Y), then replace Y by Z */
	    switch (MinMax)
	    {
	    case 0:
		if (Teval < R_Teval) {
		    for (j = 0; j <= x2_vari + 1; j++)
			ref_population[rindex][j] = temp_vec[j];
		    /*printf("Z better than Y : Initial Eval.\n");*/
		}
		break;
	    case 1:
		if (Teval > R_Teval)  {
		    for (j = 0; j <= x2_vari + 1; j++)
			ref_population[rindex][j] = temp_vec[j];
		  /*  printf("Z better than Y : Initial Eval.\n"); */
		}
		break;
	    }				    /* end of switch */



	    /*
	     * replace population[i] with temp_vec as well, depending on
	     * probab
	     */
	    p_x_z = frange_ran(0.0, 1.0);
	    if (p_x_z < 0.2)
		for (j = 0; j <= x2_vari + 1; j++)
		    population[i][j] = temp_vec[j];
	}
    }					    /* end of pop loop */

    /* repeat eval and sort for ref. population */
    /* Evaluate the best in ref_population and assign to R_Teval */
    sort(MinMax, ref_population, pop_size);

	/*printf("Inital best ref. = %f\n", ref_population[1][0]);*/


    /* Evaluate the best in population and assign it to Teval */
    sort(MinMax, population, pop_size);

	/*printf("Initialsort over...\n");*/



    fprintf(output, "\n\n");
    fprintf(output, "\n\nGeneration#\t    Solution Value\n");


    /* Assigning probability of survival for each of the agent, with the */
    /* probability provided by the user for the best agent */
    assign_probab(probab, pop_size, Q);

    /* Finding the cumulative probability of the agents */
    find_cum_probab(cum_probab, probab, pop_size);


    /* assign prob. dist for choosing ref. pop. agent for moving to */
    assign_ref_probab(ref_probab, pop_size, Q);
    


    Teval = population[1][0];
    R_Teval = ref_population[1][0];
     

    peak_val = R_Teval;


    for (j = 1; j <= pop_size; j++)
	new_genera[j][x2_vari + 1] = 0.0;

    /* Reproducing and evaluating for the total number of generations times */
    do
    {
	/* Initializing the live and die vectors */
	for (j = 1; j <= pop_size; j++)
	{
	    live[j] = die[j] = 0;
	    for (i = 0; i <= x2_vari + 1; i++)
		new_genera[j][i] = population[j][i];
	}

	/*
	 * Finding the agents that will die and the agents that will
	 * reproduce
	 */
	find_live(cum_probab, live, pop_size, P4 + P5 + P7);
	j1 = j2 = j3 = j4 = j5 = j6 = j7 = 0;

	while (j1 + j2 + j3 + j4 + j4 + j5 + j5 + j6 + j7 + j7 < P)
	{
	    oper = irange_ran(1, 7);
	    switch (oper)
	    {
	    case 1:
		/*
		 * Applying the first operator, uniform mutation, for the
		 * number of times specified
		 */
		if (j1 != P1)
		{
		    do
			first = irange_ran(2, pop_size);
		    while (die[first] == 1);
		    die[first] = 1;

		    new_genera[first][x2_vari + 1] = 1.0;
		    for (i = 1; i <= x2_vari; i++)
			t_vec[i] = population[first][i];
		    oper1(t_vec, fin_mat, rc);
		    for (i = 1; i <= x2_vari; i++)
			new_genera[first][i] = t_vec[i];
		    j1++;
		}
		break;
	    case 2:
		/*
		 * Applying the second operator, boundary mutation, for the
		 * number of times specified
		 */
		if (j2 != P2)
		{
		    do
			first = irange_ran(2, pop_size);
		    while (die[first] == 1);
		    die[first] = 1;

		    new_genera[first][x2_vari + 1] = 2.0;
		    for (i = 1; i <= x2_vari; i++)
			t_vec[i] = population[first][i];
		    oper2(t_vec, fin_mat, rc);
		    for (i = 1; i <= x2_vari; i++)
			new_genera[first][i] = t_vec[i];
		    j2++;
		}
		break;
	    case 3:
		/*
		 * Applying the third operator, non-uniform mutation, for the
		 * number of times specified
		 */
		if (j3 != P3)
		{
		    do
			first = irange_ran(2, pop_size);
		    while (die[first] == 1);
		    die[first] = 1;

		    new_genera[first][x2_vari + 1] = 3.0;
		    for (i = 1; i <= x2_vari; i++)
			t_vec[i] = population[first][i];
		    oper3(t_vec, fin_mat, rc, generations, count_gener, B);
		    for (i = 1; i <= x2_vari; i++)
			new_genera[first][i] = t_vec[i];
		    j3++;
		}
		break;

	    case 4:
		/* Applying the fourth operator, whole arithmetical crossover */
		if (j4 != (int) P4 / 2)
		{
		    /* Find two distinct parents for crossover operator 4 */
		    first_live = find_parent(live, pop_size);
		    second_live = find_parent(live, pop_size);
		    same = TRUE;
		    for (i = 1; i <= x2_vari; i++)
			if (population[first_live][i] != population[second_live][i])
			    same = FALSE;
		    if (!same)
		    {
			first_die = find_die(cum_probab, die, pop_size);
			second_die = find_die(cum_probab, die, pop_size);
			die[first_die] = 1;
			die[second_die] = 1;
			new_genera[first_die][x2_vari + 1] = 4.0;
			new_genera[second_die][x2_vari + 1] = 4.0;
			for (i = 1; i <= x2_vari; i++)
			{
			    temp[1][i] = population[first_live][i];
			    temp[2][i] = population[second_live][i];
			}
			oper4(temp[1], temp[2], x2_vari);
			for (i = 1; i <= x2_vari; i++)
			{
			    new_genera[first_die][i] = temp[1][i];
			    new_genera[second_die][i] = temp[2][i];
			}
		    }
		    j4++;
		}
		break;
	    case 5:
		/* Applying the fifth operator, simple arithmetical crossover */
		if (j5 != (int) P5 / 2)
		{
		    /* Find two distinct parents for crossover operator 5 */
		    first_live = find_parent(live, pop_size);
		    second_live = find_parent(live, pop_size);
		    same = TRUE;
		    for (i = 1; i <= x2_vari; i++)
			if (population[first_live][i] != population[second_live][i])
			    same = FALSE;
		    if (!same)
		    {
			first_die = find_die(cum_probab, die, pop_size);
			second_die = find_die(cum_probab, die, pop_size);
			die[first_die] = 1;
			die[second_die] = 1;
			new_genera[first_die][x2_vari + 1] = 5.0;
			new_genera[second_die][x2_vari + 1] = 5.0;
			for (i = 1; i <= x2_vari; i++)
			{
			    temp[1][i] = population[first_live][i];
			    temp[2][i] = population[second_live][i];
			}
			oper5(temp[1], temp[2], STEP, rc, fin_mat);
			for (i = 1; i <= x2_vari; i++)
			{
			    new_genera[first_die][i] = temp[1][i];
			    new_genera[second_die][i] = temp[2][i];
			}
		    }
		    j5++;
		}
		break;
	    case 6:
		/*
		 * Applying the sixth operator, whole non-uniform mutation,
		 * for the number of times specified
		 */
		if (j6 != P6)
		{
		    do
			first = irange_ran(2, pop_size);
		    while (die[first] == 1);
		    die[first] = 1;

		    new_genera[first][x2_vari + 1] = 6.0;
		    for (i = 1; i <= x2_vari; i++)
			t_vec[i] = population[first][i];
		    oper6(t_vec, fin_mat, rc, generations, count_gener, B);
		    for (i = 1; i <= x2_vari; i++)
			new_genera[first][i] = t_vec[i];
		    j6++;
		}
		break;
	    case 7:
		/* Applying the seventh operator */
		if (j7 != (int) P7 / 2)
		{
		    /* Find two distinct parents for operator 7 */
		    first_live = find_parent(live, pop_size);
		    second_live = find_parent(live, pop_size);
		    same = TRUE;
		    for (i = 1; i <= x2_vari; i++)
			if (population[first_live][i] != population[second_live][i])
			    same = FALSE;
		    if (!same)
		    {
			first_die = find_die(cum_probab, die, pop_size);
			die[first_die] = 1;
			new_genera[first_die][x2_vari + 1] = 7.0;
			for (i = 1; i <= x2_vari; i++)
			    if (first_live < second_live)	/* first agent is better
								 * agent */
			    {
				temp[2][i] = population[first_live][i];
				temp[1][i] = population[second_live][i];
			    } else	    /* second agent is better agent */
			    {
				temp[2][i] = population[second_live][i];
				temp[1][i] = population[first_live][i];
			    }
			oper7(temp[1], temp[2], rc, fin_mat);
			for (i = 1; i <= x2_vari; i++)
			    new_genera[first_die][i] = temp[1][i];
		    }
		    j7++;
		}
	    }
	}

	/* Replace the population with the new generation */
	new = new_genera;