AGSO 萤火虫算法

-- 今天用LUA写了一个萤火虫算法..发现很差....可能写的不对..改天再改一下

--算法说明：荧火虫算法


-- ================================初始化开始================================
domx = { { -1, 2 }, { -1, 2 } }; -- 定义域
rho = 0.4 --荧光素挥发因子
gamma = 0.6 -- 适应度提取比例
beta = 0.08 -- 邻域变化率
nt = 5 -- 邻域阀值(邻域荧火虫数)
s = 0.3 -- 步长
s1 = 0.03 -- 局部最优扰动
iot0 = 5 -- 荧光素浓度
rs = 1.5 -- 感知半径
r0 = 1.5 -- 决策半径
-- ================================初始化结束================================

-- ===============================分配空间开始===============================
m = 2 -- 解空间维数
n = 30 -- 群规模
gaddress = {} -- 分配荧火虫地址空间
gvalue = {} -- 分配适应度存放空间
ioti = {} -- 分配荧光素存放空间
rdi = {} -- 分配荧火虫决策半径存放空间
-- ===============================分配空间结束===============================


-- ===================================函数===================================
sin = math.sin
sqrt = math.sqrt
pi = math.pi
random = math.random

-- 求解函数
function maxfun(x)
    return 4 - (x[1] * sin( 4 * pi * x[1]) - x[2] * sin(4 * pi * x[2] + pi + 1))
end

-- 求2范数 维数相关
function norm(xi, xj)
    return sqrt((xi[1] - xj[1]) ^ 2 + (xi[2] - xj[2]) ^ 2)
end

print(maxfun({1.88, 1.81}))
print(maxfun({1.8506610777502, 1.8685277417146})) -- 6.8987454465589


-- ===========================荧火虫常量初始化开始============================
math.randomseed(os.time())

-- 初始化个体
for i = 1, n do
    gaddress[i] = {}
    for j = 1, m do
        gaddress[i][j] = domx[j][1] + (domx[j][2] - domx[j][1]) * random()
    end
end

-- 初始化荧光素
for i = 1, n do
    ioti[i] = iot0
end


-- 初始化决策半径
for i = 1, n do
    rdi[i] = r0
end
-- ===========================荧火虫常量初始化结束============================


-- =============================iter_max迭代开始=============================

-- 最大迭代次数
iter_max = 20

for iter = 1, iter_max do

    -- 下面我加了一个变异操作
    j = 1
    for i = 1, n do
        gvalue[i] = maxfun(gaddress[i])
        if gvalue[j] > gvalue[i] then
            j = i
        end
    end

    for k = 1, m do
        gaddress[j][k] = domx[k][1] + (domx[k][2] - domx[k][1]) * random()
    end
    gvalue[j] = maxfun(gaddress[j])
    

    -- 更新荧光素
    for i = 1, n do
        ioti[i] = (1 - rho) * ioti[i] + gamma * gvalue[i]
    end

    -- 各荧火虫移动过程开始
    for i = 1, n do
        -- 决策半径内找更优点
        Nit = {} -- 存放荧火虫序号
        for j = 1, n do
            if j ~= i and ioti[i] < ioti[j] and norm(gaddress[j], gaddress[i]) < rdi[i] then
                table.insert(Nit, j)
            end
        end

        -- 找下一步移动的点开始
        Nitnum = #Nit
        if Nitnum > 0 then
            
            -- 选出Nit荧光素之差及差的总和
            Nitioti = {}
            Denominator = 0
            for k = 1, Nitnum do
                Nitioti[k] = ioti[Nit[k]] - ioti[i]
                Denominator = Denominator + Nitioti[k]
            end

            -- 求出各个选择概率
            Nitioti[1] = Nitioti[1] / Denominator
            for k = 2, Nitnum do
                Nitioti[k] = Nitioti[k] / Denominator + Nitioti[k - 1]
            end

            -- 轮盘赌
            rand = random()
            idx = 1
            for k = 1, Nitnum do
                if rand < Nitioti[k] then
                    idx = Nit[k]
                    break
                end
            end

            -- 移动
            dist = norm(gaddress[idx], gaddress[i])
            for k = 1, m do
                gaddress[i][k] = gaddress[i][k] + s * (gaddress[idx][k] - gaddress[i][k]) / dist
                if gaddress[i][k] < domx[k][1] then
                    gaddress[i][k] = domx[k][1]
                elseif gaddress[i][k] > domx[k][2] then
                    gaddress[i][k] = domx[k][2]
                end
            end

            -- 更新决策半径
            rdi[i] = rdi[i] + beta * (nt - Nitnum)
            if rdi[i] < 0 then
                rdi[i] = 0
            elseif rdi[i] > rs then
                rdi[i] = rs
            end
        else
            for k = 1, m do
                gaddress[i][k] = gaddress[i][k] + s1 * (random() - 0.5) * (domx[k][2] - domx[k][1])
                if gaddress[i][k] < domx[k][1] then
                    gaddress[i][k] = domx[k][1]
                elseif gaddress[i][k] > domx[k][2] then
                    gaddress[i][k] = domx[k][2]
                end
            end
        end
    end
end

-- =============================iter_max迭代结束=============================



-- =============================输出最优结果开始=============================

-- 求各个荧火虫的值
j = 1
for i = 1, m do
    gvalue[i] = maxfun(gaddress[i])
    if gvalue[i] < gvalue[j] then
        j = i
    end
end

-- 最大值
BestAddress = gaddress[j]
print("(" .. BestAddress[1] .. ", " .. BestAddress[2] .. ")\t" .. gvalue[j])
-- =============================输出最优结果结束=============================

 

 

C语言版

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


#define RND          ((float)rand()/(RAND_MAX + 1))
#define PI           (3.14159265359)

/* 问题相关 */
const int X_DIM = 10;


//double domx[2] = { -30, 30 };
//double get_y( double x[X_DIM] )
//{
//    register int i, j;
//    register double sum, sum1;
//
//    sum = 0.0;
//    j = X_DIM - 1;
//    for ( i = 0; i < j; i ++ )
//    {
//        sum1 = x[i + 1] - x[i] * x[i];
//        sum += 100 * sum1 * sum1;
//        sum1 = x[i] - 1;
//        sum += sum1 * sum1;
//    }
//    return sum;
//}


double domx[2] = { -100, 100 };
double get_y( double x[X_DIM] )
{
    register int i;
    register double sum;

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



/* 萤火虫结构 */
typedef struct tag_gso
{
    double x[X_DIM];
    double l;
    double rd;
    double y;
} gso_t, *gso_ptr;


/* 参数 */
const int gsonum = 100;            /* 种群大小 */
const double initl = 5.0;          /* 初始萤光素值 */
const double rho = 0.4;            /* 萤光素挥发系数 */
const double gamma = 0.6;          /* 适应度影响因子 */
const double beta = 0.08;          /* 邻域变化率 */
const double s = 0.8;              /* 移动步长 */
const int nt = 5;                  /* 邻域阀值 */
const double initr = 400;          /* 初始决策半径 */
const double rs = 650;             /* 最大决策半径 */


/* 数据定义 */
gso_t gsos[gsonum];                /* 种群 */
gso_t optimum;                     /* 最优个体 */
double gsodist[gsonum][gsonum];    /* 距离矩阵 */
int tabu[gsonum];                  /* 禁忌表 */
int ninum[gsonum];                 /* 邻域集 */
int maxiter;                       /* 最大迭代次数 */




double dist_gso( int idx1, int idx2 )
{
    register int i;
    register double sum, sum1;

    sum = 0.0;
    for ( i = 0; i < X_DIM; i ++ )
    {
        sum1 = gsos[idx1].x[i] - gsos[idx2].x[i];
        sum += sum1 * sum1;
    }

    return sqrt( sum );
}



void init_single_gso( int idx )
{
    register int i;

    for ( i = 0; i < X_DIM; i ++ )
    {
        gsos[idx].x[i] = domx[0] + ( domx[1] - domx[0] ) * RND;
    }
    gsos[idx].y = get_y( gsos[idx].x );
    gsos[idx].l = initl;
    gsos[idx].rd = initr;

    if ( gsos[idx].y < optimum.y )
    {
        memcpy( &optimum, gsos + idx, sizeof( gso_t ) );
    }
}



void init_gsos()
{
    register int i;

    for ( i = 0; i < gsonum; i ++ )
    {
        init_single_gso( i );
    }
}


void move_gso( int idx1, int idx2 )
{
    register int i;

    for ( i = 0; i < X_DIM; i ++ )
    {
        gsos[idx1].x[i] += s * ( gsos[idx2].x[i] - gsos[idx1].x[i] ) / gsodist[idx1][idx2];

        if ( gsos[idx1].x[i] < domx[0] )
        {
            gsos[idx1].x[i] = domx[0];
        }
        else if ( gsos[idx1].x[i] > domx[1] )
        {
            gsos[idx1].x[i] = domx[1];
        }
    }

    gsos[idx1].y = get_y( gsos[idx1].x );
    if ( gsos[idx1].y < optimum.y )
    {
        memcpy( &optimum, gsos + idx1, sizeof( gso_t ) );
    }
}



int main()
{
    int i, j, k;
    int iter;
    double sum, partsum[gsonum + 1];
    double rnd;

    /* 初始化随机数发生器 */
    srand( ( unsigned int )time( NULL ) );

    /* 无穷大 */
    optimum.y = 1000000000000;

    /* 初始化种群 */
    init_gsos();

    /* 置迭代次数 */
    maxiter = 5000;


    /* 迭代 */
    for ( iter = 0; iter < maxiter; iter ++ )
    {
        /* 更新荧光素 */
        for ( i = 0; i < gsonum; i ++ )
        {
            gsos[i].l = ( 1 - rho ) * gsos[i].l + gamma / gsos[i].y;
        }

        /* 清ni集计数 */
        memset( ninum, 0, sizeof( ninum ) );

        for ( i = 0; i < gsonum; i ++ )
        {
            /* 构建ni */
            memset( tabu, 0, sizeof( tabu ) );

            for ( j = 0; j < gsonum; j ++ )
            {
                if ( i != j && gsos[i].l < gsos[j].l )
                {
                    gsodist[i][j] = dist_gso( i, j );
                    if ( gsodist[i][j] < gsos[i].rd )
                    {
                        tabu[j] = 1;
                        ninum[i] ++;
                    }
                }
            }

            if ( ninum[i] > 0 )
            {
                /* 轮盘赌 */
                sum = 0.0;
                for ( j = 0; j < gsonum; j ++ )
                {
                    if ( tabu[j] == 1 )
                    {
                        sum += gsos[j].l - gsos[i].l;
                    }
                }

                k = 1;
                partsum[0] = 0.0;
                for ( j = 0; j < gsonum; j ++ )
                {
                    if ( tabu[j] == 1 )
                    {
                        partsum[k] = partsum[k - 1] + ( gsos[j].l - gsos[i].l ) / sum;
                        k ++;
                    }
                }
                partsum[k - 1] = 1.1;

                rnd = RND;
                k = 1;
                for ( j = 0; j < gsonum; j ++ )
                {
                    if ( tabu[j] == 1 && rnd < partsum[k ++] )
                    {
                        break;
                    }
                }

                /* 选出j移动位置 */
                move_gso( i, j );
            }

            gsos[i].rd += beta * ( nt - ninum[i] );
            if ( gsos[i].rd < 0 )
            {
                gsos[i].rd = 0;
            }
            else if ( gsos[i].rd > rs )
            {
                gsos[i].rd = rs;
            }
        }

        fprintf( stdout, "best=%.15f\n", optimum.y );
    }

    return 0;
}