人工鱼群算法 AFSA

寻优还可以，速度跟不上.. 国产的支持一把

-- 人工鱼群算法 AFSA

-- 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 = 1
-- ====================================================================

-- ================================定义================================
fishnum = 60                            -- 鱼群大小
fishes = {}                             -- 鱼群
visual = 0.1                            -- 可视范围
delta = 0.05                            -- 拥挤因子
step = 0.01                             -- 步长
trynum = 50                             -- 尝试次数
gbest = {}                              -- 全局最优
neighbour = {}                          -- 邻居  中间变量
itermax = 120                            -- 迭代次数
-- ====================================================================


-- ==============================工具函数==============================

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

-- 修正范围
function fixx(x)
    dx = domx[funidx]
    for i = 1, dim do
        if x[i] < dx[i][1] then
            x[i] = dx[i][1]
        elseif x[i] > dx[i][2] then
            x[i] = dx[i][2]
        end
    end
end

-- 鱼群初始化
function fishinit()
    -- 初始化
    for i = 1, fishnum do
        fishes[i] = { v = {} }
        for j = 1, dim do
            fishes[i][j] = domx[funidx][j][1] + (domx[funidx][j][2] - domx[funidx][j][1]) * random()
            fishes[i].v[j] = fishes[i][j]
        end
        fishes[i].y = maxfun[funidx](fishes[i])
        fishes[i].v.y = fishes[i].y
    end

    visual = domx[funidx][1][2] - domx[funidx][1][1]
    for j = 2, dim do
        dist = domx[funidx][j][2] - domx[funidx][j][1]
        if dist < visual then visual = dist end
    end

    visual = visual / 8
end

-- 觅食
function fishfeed(idx)
    sign = 0
    tmppos = {}
    fish = {}
    for i = 1, trynum do
        for j = 1, dim do tmppos[j] = fishes[idx][j] + random() * step * visual end
        if fishes[idx].y < maxfun[funidx](tmppos) then
            sign = 1
            dist = norm(fishes[idx], tmppos)
            for j = 1, dim do fish[j] = fishes[idx][j] + random() * step * (tmppos[j] - fishes[idx][j]) / dist end
            break
        end
    end

    if sign == 0 then
        for j = 1, dim do fish[j] = fishes[idx][j] + random() * step end
    end

    return fish
end

-- 聚集
function assemblefish(idx)
    nfish = 0
    center = {}
    neighbour = {}
    for j = 1, dim do center[j] = 0 end
    for i = 1, fishnum do
        if norm(fishes[i], fishes[idx]) < visual then
            if i ~= idx then table.insert(neighbour, i) end
            for j = 1, dim do center[j] = center[j] + fishes[i][j] end
            nfish = nfish + 1
        end
    end

    for j = 1, dim do center[j] = center[j] / nfish end
    center.y = maxfun[funidx](center)

    fish = {}
    if fishes[idx].y < center.y then
        dist = norm(fishes[idx], center)
        for j = 1, dim do fish[j] = fishes[idx][j] + random() * step * (center[j] - fishes[idx][j]) / dist end
        return fish
    end
        
    return fishfeed(idx)
end

-- 追尾
function followfish(idx)

    if #neighbour == 0 then return fishfeed(idx) end

    idx1 = neighbour[1]
    for i = 2, #neighbour do
        if fishes[neighbour[i]].y > fishes[idx1].y then idx1 = neighbour[i] end
    end
    
    if fishes[idx1].y < fishes[idx].y then return fishfeed(idx) end

    fish = {}
    if fishes[idx1].y / #neighbour > delta * fishes[idx].y then
        dist = norm(fishes[idx], fishes[idx1])
        for j = 1, dim do fish[j] = fishes[idx][j] + random() * step * (fishes[idx1][j] - fishes[idx][j]) / dist end
        return fish
    end

    return fishfeed(idx)
end

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



-- ===============================主函数===============================
function main(idx)
    -- 功能选择
    funidx = idx
    -- 系统初始化
    fishinit()
    
    -- 开始迭代
    for iter = 1, itermax do
        for i = 1, fishnum do
            next1 = assemblefish(i)
            fixx(next1)
            next1.y = maxfun[funidx](next1)

            next2 = followfish(i)
            fixx(next2)
            next2.y = maxfun[funidx](next2)

            if next2.y > next1.y then
                next1, next2 = next2, next1
            end

            if next1.y > fishes[i].y then
                for j = 1, dim do fishes[i][j] = next1[j] end
                fishes[i].y = next1.y
                if fishes[i].y > fishes[i].v.y then
                    for j = 1, dim do fishes[i].v[j] = fishes[i][j] end
                    fishes[i].v.y = fishes[i].y
                end
            end
        end
    end

    maxy = 1
    for i = 2, fishnum do
        if fishes[i].y > fishes[maxy].y then maxy = i end
    end

    gbest = fishes[maxy]

end

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

t1 = os.clock()

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

t2 = os.clock()

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