遗传算法 GA

保留精英, 选择函数可能有问题

-- 遗传算法 GA

-- lua 相关简易操作
sin = math.sin
cos = math.cos
sqrt = math.sqrt
pi = math.pi
random = math.random
exp = math.exp
int = math.floor


-- 获得不同的随机序列
math.randomseed(os.time())


-- ==============================求解函数==============================
dim = 2                                 -- 解的维数

domx = {                                -- 定义域
    { { -1, 2 }, { -1, 2 } },
    { {  2, 4 }, { -1, 1 } },
    { {  0, 4 }, {  0, 4 } },
}

maxfun = {                              -- 求解函数
    function(x) return 4 - (x[1] * sin( 4 * pi * x[1]) - x[2] * sin(4 * pi * x[2] + pi + 1)) end            ,
    function(x) return exp(x[1] - x[2] * x[2]) / (x[1] * x[1] - x[2]) + (x[1] - 3) ^ 2 end                  ,
    function(x) return 2 + (x[1] * x[1] + x[2] * x[2]) / 10 - (cos(2 * pi * x[1]) + cos(2 * pi * x[2])) end ,
}

funidx = 0
-- ====================================================================

-- ================================定义================================
chromnum = 30                           -- 染色体个数
chroms = {}                             -- 染色体
px = 0.7                                -- 交叉概率
pm = 0.2                                -- 变异概率
deltax = {}                             -- 编码最小单位
gbest = { v = {} }                      -- 全局最优
itermax = 80                           -- 迭代次数
-- ====================================================================


-- ==============================工具函数==============================
-- 评价函数
function getfitness(y) return y end

-- 染色体群初始化
function createchrom()
    
    for j = 1, dim do
        deltax[j] = (domx[funidx][j][2] - domx[funidx][j][1]) / 65536
    end

    for i = 1, chromnum do
        chroms[i] = { v= {} }
        for j = 1, dim do
            chroms[i][j] = int(65536 * random())
            chroms[i].v[j] = chroms[i][j] * deltax[j] + domx[funidx][j][1]
        end
        chroms[i].y = maxfun[funidx](chroms[i].v)
        chroms[i].fitness = getfitness(chroms[i].y)
    end

    maxidx = 1
    for i = 2, chromnum do
        if chroms[i].fitness > chroms[maxidx].fitness then
            maxidx = i
        end
    end

    gbest.y = chroms[maxidx].y
    gbest.fitness = chroms[maxidx].fitness
    for i = 1, dim do
        gbest[i] = chroms[maxidx][i]
        gbest.v[i] = chroms[maxidx].v[i]
    end

end


-- 交叉
function crosschrom()
    -- 存储要交叉的索引
    idxlist = {}
    for i = 1, chromnum do
        if random() < px and i ~= gbest then
            table.insert(idxlist, i)
        end
    end

    if #idxlist < 3 then return end

    -- 打乱顺序
    cnt = #idxlist
    for i = 1, cnt do
        idx = int(random() * cnt) + 1
        if idx ~= i then
            idxlist[i], idxlist[idx] = idxlist[idx], idxlist[i]
        end
    end

    -- 两两交叉
    for i = 2, cnt, 2 do
        c1 = chroms[idxlist[i - 1]]
        c2 = chroms[idxlist[i]]
        for j = 1, dim do
            pos = int(random() * 14) + 1 -- 16位染色体,这样写居中一些
            
            tmpa = bit32.extract(c1[j], 0, pos)
            tmpb = bit32.extract(c2[j], 0, pos)

            c1[j] = bit32.replace(c1[j], tmpb, 0, pos)
            c1.v[j] = c1[j] * deltax[j] + domx[funidx][j][1]

            c2[j] = bit32.replace(c2[j], tmpa, 0, pos)
            c2.v[j] = c2[j] * deltax[j] + domx[funidx][j][1]
        end

        c1.y = maxfun[funidx](c1.v)
        c1.fitness = getfitness(c1.y)

        c2.y = maxfun[funidx](c2.v)
        c2.fitness = getfitness(c2.y)
    end
end


-- 变异
function mutatechrom()
    for i = 1, chromnum do
        if random() < pm then
            c = chroms[i]
            for j = 1, dim do
                pos = int(random() * 16)
                c[j] = bit32.bxor(c[j], 2 ^ pos)
                c.v[j] = c[j] * deltax[j] + domx[funidx][j][1]
            end
            c.y = maxfun[funidx](c.v)
            c.fitness = getfitness(c.y)
        end
    end
end

-- 选择
function selectchrom()
    
    sum = 0
    for i = 1, chromnum do
        sum = sum + chroms[i].fitness
    end

    dist = {}
    dist[1] = chroms[1].fitness / sum
    for i = 2, chromnum do dist[i] = chroms[i].fitness / sum + dist[i - 1] end
    dist[chromnum] = 1

    chroms1 = {}
    for cnt = 1, chromnum do
        idx = 0
        rnd = random()
        for i = 1, chromnum do
            if rnd < dist[i] then
                idx = i
                break
            end
        end
        chroms1[cnt] = { v= {} }
        for j = 1, dim do
            chroms1[cnt][j] = chroms[idx][j]
            chroms1[cnt].v[j] = chroms[idx].v[j]
        end
        chroms1[cnt].y = chroms[idx].y
        chroms1[cnt].fitness = chroms[idx].fitness
    end
    
    chroms = chroms1

    minidx = 1
    maxidx = 1
    for i = 2, chromnum do
        if chroms[i].fitness < chroms[minidx].fitness then
            minidx = i
        elseif chroms[i].fitness > chroms[maxidx].fitness then
            maxidx = i
        end
    end

    if chroms[minidx].fitness < gbest.fitness then
        chroms[minidx].fitness = gbest.fitness
        chroms[minidx].y = gbest.y
        for i = 1, dim do
            chroms[minidx][i] = gbest[i]
            chroms[minidx].v[i] = gbest.v[i]
        end
    end

    if chroms[maxidx].fitness > gbest.fitness then
        gbest.fitness = chroms[maxidx].fitness
        gbest.y = chroms[maxidx].y
        for i = 1, dim do
            gbest[i] = chroms[maxidx][i]
            gbest.v[i] = chroms[maxidx].v[i]
        end
    end
end

-- ====================================================================


-- ===============================主函数===============================
function main(idx)
    -- 功能选择
    funidx = idx
    -- 系统初始化
    createchrom()
    
    -- 开始迭代
    for iter = 1, itermax do

        crosschrom()

        mutatechrom()
    
        selectchrom()
    end
end

-- ===============================主函数===============================

t1 = os.clock()

main(1)
print(string.format("函数值为: %.8f \t解为: (%.3f, %.3f)", gbest.y, gbest.v[1], gbest.v[2]))
main(2)
print(string.format("函数值为: %.8f \t解为: (%.3f, %.3f)", gbest.y, gbest.v[1], gbest.v[2]))
main(3)
print(string.format("函数值为: %.8f \t解为: (%.3f, %.3f)", gbest.y, gbest.v[1], gbest.v[2]))

t2 = os.clock()

print("times: ", 1000 * (t2 - t1))