BFOA

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>

#define PI       (3.1415926f)
#define RND      ((float)rand() / (RAND_MAX + 1))
#define X_DIM    30

//float domx[X_DIM][2] =
//{
//    { -1.0f, 2.0f}, { -1.0f, 2.0f}
//};

float domx[2] = { -100.0f, 100.0f};

const int S = 100;             // 细菌个数
float bacterium[S][X_DIM];    // 细菌
const int Nc = 50;            // 趋化的次数
float bacterafitness[S][Nc];  // 适应度
const int Ns = 10;             // 趋化操作中单向运动的最大步数4
const int Nre = 20;            // 复制次数
const int Ned = 20;            // 驱散次数
const float Ped = 0.25f;      // 驱散概率
const float Ci = 1.0f;      // 步长

float gbest;
float gx[X_DIM];



const float d_at = 0.05f;         // 吸引剂的数量
const float w_at = 0.05f;         // 吸引剂的释放速度
const float h_re = 0.05f;         // 排斥剂的数量
const float w_re = 0.05f;         // 排斥剂的释放速度





float get_y1( float x[X_DIM] )
{
    return 4 - ( x[0] * sin( 4 * PI * x[0] ) - x[1] * sin( 4 * PI * x[1] + PI + 1 ) );
}

float get_y( float x[X_DIM] )
{
    register int i;
    register float sum;

    sum = 0.0f;
    for ( i = 0; i < X_DIM; i ++ )
    {
        sum -= x[i] * x[i];
    }
    return sum;
}

float fitness( float y )
{
    return y;
}

float get_jcc( int idx )
{
    register int i, j;
    register float a, allsum, sum, sum1, sum2;


    allsum = 0.0f;
    for ( i = 0; i < S; i ++ )
    {
        sum = 0.0f;
        for ( j = 0; j < X_DIM; j ++ )
        {
            a = bacterium[i][j] - bacterium[idx][j];
            sum += a * a;
        }

        sum1 = -w_at * sum;
        sum1 = -d_at * exp( sum1 );

        sum2 = -w_re * sum;
        sum2 = h_re * exp( sum2 );

        allsum += sum1 + sum2;
    }


    return allsum;
}







void init_single_bacterium( float x[X_DIM] )
{
    register int i;

    for ( i = 0; i < X_DIM; i ++ )
    {
        x[i] = domx[0] + RND * ( domx[1] - domx[0] );
    }
}



void init_bacterium()
{
    register int i, j;

    for ( i = 0; i < S; i ++ )
    {
        for ( j = 0; j < X_DIM; j ++ )
        {
            bacterium[i][j] = domx[0] + RND * ( domx[1] - domx[0] );
        }
    }
}

void get_delta( float delta[X_DIM] )
{
    register int i;
    register float tmp;

    tmp = 0.0f;
    for ( i = 0; i < X_DIM; i ++ )
    {
        delta[i] = ( RND - 0.5f ) * 2;

        tmp += delta[i] * delta[i];
    }

    tmp = sqrt( tmp );

    for ( i = 0; i < X_DIM; i ++ )
    {
        delta[i] /= tmp;
    }
}







int main()
{
    register int i, j, k, l, m, n;
    float f, f1, y, flast, tmpfit;
    float delta[X_DIM];
    float tmpbactera[X_DIM];
    float bfsum[S];
    int Sr;


    srand( ( unsigned int )time( NULL ) );

    gbest = -10000000000.0f;
    Sr = S / 2;
    init_bacterium();


    for ( l = 0; l < Ned; l ++ )
    {
        for ( k = 0; k < Nre; k ++ )
        {
            for ( j = 0; j < Nc; j ++ )
            {
                for ( i = 0; i < S; i ++ )
                {
                    y = get_y( bacterium[i] );

                    if ( y > gbest )
                    {
                        gbest = y;
                        memcpy( gx, bacterium[i], sizeof( gx ) );
                    }

                    f = fitness( y );
                    f += get_jcc( i );

                    flast = f;

                    get_delta( delta );

                    for ( n = 0; n < X_DIM; n ++ )
                    {
                        tmpbactera[n] = Ci * delta[n] + bacterium[i][n];
                    }

                    for ( m = 0; m < Ns; m ++ )
                    {
                        f1 = fitness( get_y( tmpbactera ) );
                        if ( f1 > flast )
                        {
                            flast = f1;
                            for ( n = 0; n < X_DIM; n ++ )
                            {
                                tmpbactera[n] += Ci * delta[n];
                            }
                        }
                        else
                        {
                            break;
                        }
                    }

                    memcpy( bacterium[i], tmpbactera, sizeof( bacterium[0] ) );
                    bacterafitness[i][j] = flast;
                }


                printf( "[%02d,%02d,%02d]\tgbest=%f\t(%f,%f)\n", l, k, j, gbest, gx[0], gx[1] );
            }


            for ( i = 0; i < S; i ++ )
            {
                bfsum[i] = 0.0f;
                for ( j = 0; j < Nc; j ++ )
                {
                    bfsum[i] += bacterafitness[i][j];
                }
            }

            for ( n = 0; n < Sr; n ++ )
            {
                i = n;
                tmpfit = bfsum[n];
                for ( j = n + 1; j < S; j ++ )
                {
                    if ( bfsum[j] > tmpfit )
                    {
                        tmpfit = bfsum[j];
                        i = j;
                    }
                }

                if ( i != n )
                {
                    memcpy( tmpbactera, bacterium[n], sizeof( tmpbactera ) );
                    memcpy( bacterium[n], bacterium[i], sizeof( bacterium[0] ) );
                    memcpy( bacterium[i], tmpbactera, sizeof( bacterium[0] ) );
                }
            }

            for ( i = 0; i < Sr; i ++ )
            {
                memcpy( bacterium[Sr + i], bacterium[i], sizeof( bacterium[0] ) );
            }
        }

        for ( i = 0; i < S; i ++ )
        {
            if ( RND < Ped )
            {
                init_single_bacterium( bacterium[i] );
            }
        }
    }

    return 0;
}