frange_ran.c

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

	do
	{
	    LOCAL_CHECK = TRUE;
	    printf("Please input initial values\n");
	    for (i = 1; i <= x1_vari + x2_vari; i++)
	    {
		printf("\nX%d\t", i);
		scanf("%f", &X[i]);
	    }

	    for (j = 1; j <= rc.r; j++)
	    {
		sum = 0.0;
		for (i = 1; i <= x2_vari; i++)
		    /*
		     * Evaluate the equation after a value is generated for a
		     * variable
		     */
		    sum = sum + X[x2[i]] * final[j][i + 1];

		/* Check if the lower and upper bounds are satisfied */
		_LOW = (sum >= final[j][1]) ? TRUE : FALSE;
		_HIGH = (sum <= final[j][rc.c]) ? TRUE : FALSE;
		/* if NL specified, check for NL as well */
		if (bothflag == TRUE)
			NL_CHECK = nonlinear(X, ninumber, nenumber, epsilon);

		if ((!_LOW) || (!_HIGH) || (!NL_CHECK))
		{
		    printf("The input values do not satisfy the constraint #%d\n", j);
		    printf("NL_CHECK = %d, bothflag = %d\n", NL_CHECK, bothflag);
		    LOCAL_CHECK = FALSE;
		}
	    }
	} while (LOCAL_CHECK == FALSE);	    /* end of do...while LOCAL_CHECK */
    }
     /* end of if try > TRIES ......................... */ 
    else
    {
	if (x1_vari != 0)
	{
	    for (i = 1; i <= x2_vari; i++)
		X[x2[i]] = temp[i];

	    for (j = 1; j <= x1_vari; j++)
	    {
		X[x1[j]] = a1_b[j];
		for (i = 1; i <= x2_vari; i++)
		    X[x1[j]] = X[x1[j]] + temp[i] * final[j + x2_vari][i + 1];
	    }
	} else
	    for (i = 1; i <= x2_vari; i++)
		X[i] = temp[i]; 

    }
    free_vector(temp, 1);
    free_matrix(trymat, 1, rc.r - x2_vari, 0);

    return (_CHECK);
}

/********************************************************************************/
/*                                                                              */
/*           FUNCTION NAME     :   seed()                                       */
/*                                                                              */
/*           SYNOPSIS          :   void seed()                                  */
/*                                                                              */
/*           DESCRIPTION       :   This function generates the seed for         */
/*                                  generating the random numbers and           */
/*                                  warms up the generator.                     */
/*                                                                              */
/*           FUNCTIONS CALLED  :   randint(),                                   */
/*                                 newrand()                                    */
/*                                                                              */
/*           CALLING FUNCTIONS :   main(),                                      */
/*                                                                              */
/*           AUTHOR            :   Tom Logan                                    */
/*                                                                              */
/*           DATE              :   2/28/93                                      */
/*                                                                              */
/*                                                                              */
/*           REV            DATE            BY           DESCRIPTION            */
/*           ---            ----            --           -----------            */
/*                                                                              */
/*                                                                              */
/********************************************************************************/


void 
seed()
{
    long            l_time;
    int             n;
    unsigned int    x;

    l_time = time(NULL);
    l_time = l_time % 65536;
    rseed = l_time;

    for (n = 0; n < SHUFFLE; n++)	    /* initialize random number array */
	rand_array[n] = randint();
    for (n = 0; n < 1000; n++)		    /* warm up the generator */
	x = newrand();
}


/********************************************************************************/
/*                                                                              */
/*           FUNCTION NAME     :   randint()                                    */
/*                                                                              */
/*           SYNOPSIS          :   unsigned int randint()                       */
/*                                                                              */
/*           DESCRIPTION       :   This function generates returns a random     */
/*                                  number (unsigned int). newrand() should     */
/*                                  be used as the actual random number         */
/*                                  genertor. This function is called by        */
/*                                  newrand().                                  */
/*                                                                              */
/*           FUNCTIONS CALLED  :   none                                         */
/*                                                                              */
/*           CALLING FUNCTIONS :   newrand(),                                   */
/*                                 seed()                                       */
/*                                                                              */
/*           AUTHOR            :   Tom Logan                                    */
/*                                                                              */
/*           DATE              :   2/28/93                                      */
/*                                                                              */
/*                                                                              */
/*           REV            DATE            BY           DESCRIPTION            */
/*           ---            ----            --           -----------            */
/*                                                                              */
/*                                                                              */
/********************************************************************************/
unsigned int 
randint()
{
    int             num;

    rseed = (MULT * rseed + INCR) % MOD;
    num = rseed % 65536;
    return (num);
}



/********************************************************************************/
/*                                                                              */
/*           FUNCTION NAME     :   newrand()                                    */
/*                                                                              */
/*           SYNOPSIS          :   unsigned int newrand()                       */
/*                                                                              */
/*           DESCRIPTION       :   This function generates returns a random     */
/*                                  number (unsigned int).                      */
/*                                                                              */
/*           FUNCTIONS CALLED  :   randint()                                    */
/*                                                                              */
/*           CALLING FUNCTIONS :   seed(),                                      */
/*                                 flip() in genocop.h,                         */
/*                                 irange_ran                                   */
/*                                                                              */
/*           AUTHOR            :   Tom Logan                                    */
/*                                                                              */
/*           DATE              :   2/28/93                                      */
/*                                                                              */
/*                                                                              */
/*           REV            DATE            BY           DESCRIPTION            */
/*           ---            ----            --           -----------            */
/*                                                                              */
/*                                                                              */
/********************************************************************************/
unsigned int 
newrand()
{
    int             r_offset;
    unsigned int    ran_int;

    r_offset = (int) (randint() % SHUFFLE);
    ran_int = rand_array[r_offset];
    rand_array[r_offset] = randint();
    return (ran_int);
}