精华内容
下载资源
问答
  • 将蚁群优化算法的正反馈特性与实数遗传算法的进化策略相结合,克服了基本蚁群算法只适用于离散问题的局限性,并提高了寻优的效率、全局的寻优能力和结果的稳定性。在计算过程中,根据不等式约束越界量的大小,动态...
  • %% 算法开始 for iter=1:Times %迭代次数    for i = 1:N_ants%遍历每只蚂蚁 % pos = ceil((N+1)*rand(1,N_vars))%随机放置蚂蚁  %% 将变量区间进行划分网格   for j = 1:N_vars  h(j) = ...
     clc 
    clear all;
    global N
    %---------- initialization of variable---------%
    N = 60;%等分区间的数量
    N_ants=50 ;%蚂蚁的数目
    N_vars = 30;%变量数量
    Times=250;%迭代的次数
    Q = 10;%信息量强度
    Rou=0.05;%信息量残留因子
    % det = ceil(N/4);%最优解为中心 上下浮动的程度范围一般为[1,6]
    det = 4;
    index = 2;% 概率计算公式中分子的指数 
    %----------------------------------------------%


    % -----------F Domain---------%
    %     Lower(1) = 0;
    %     Upper(1) = 2;
    %     Lower(2) = 1;
    %     Upper(2) = 3;
     
    % -------------------------------%
    % -----------F1 F3 F4 F5 F Domain---------%
    for i = 1:N_vars
        Lower(i) = -100;
        Upper(i) = 100;
    end
    % -------------------------------%
    %-----------F3 Domain-----------%
    % for i = 1:N_vars
    %     Lower(i) = -10;
    %     Upper(i) = 10;
    % end
    %-------------------------------%
    %-----------F6 Domain-----------%
    % for i = 1:N_vars
    %     Lower(i) = -1.28;
    %     Upper(i) = 1.28;
    % end
    %-------------------------------%
    %-----------F7 Domain-----------%
    % for i = 1:N_vars
    %     Lower(i) = -500;
    %     Upper(i) = 500;
    % end
    %-------------------------------%
    %-----------F8 F16 Domain-----------%
    % for i = 1:N_vars
    %     Lower(i) = -5.12;
    %     Upper(i) = 5.12;
    % end
    %-------------------------------%
    %-----------F9  F17 Domain-----------%
    % for i = 1:N_vars
    %     Lower(i) = -32;
    %     Upper(i) = 32;
    % end
    %-------------------------------%
    %-----------F10 F11 Domain-----------%
    % for i = 1:N_vars
    %     Lower(i) = -50;
    %     Upper(i) = 50;
    % end
    %-------------------------------%
    %-----------F12 Domain-----------%
    % for i = 1:N_vars
    %     Lower(i) = -5;
    %     Upper(i) = 5;
    % end
    %-------------------------------%
    %-----------F13 F14 F15 Domain-----------%
    % for i = 1:N_vars
    %     Lower(i) = 0;
    %     Upper(i) = 10;
    % end
    %-------------------------------%
    tao(1:N+1,1:N_vars) = 1/(N+1);
    % tao(N+1,:) = 0.01
    x_best = Lower;
    % fx_best = feval(f,x_best);
    fx_best = F1(x_best);%!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    x(1,N_vars) = 0;
    tao_sum(N_vars) = 0;
    P(N+1,N_vars) = 0;
    pos = ceil((N+1)*rand(1,N_vars)) %随机放置蚂蚁  
    %% 算法开始
    for iter=1:Times %迭代次数
        
        for i  = 1:N_ants%遍历每只蚂蚁
    %        pos = ceil((N+1)*rand(1,N_vars))%随机放置蚂蚁  
           %% 将变量区间进行划分网格 
           for j = 1:N_vars
               h(j) = (Upper(j)-Lower(j))/N;%划分后区间的大小
               
    %            x(j) = Lower(j)+(pos(j)-1)*h(j);%计算蚂蚁当前位置(区间)的 左区间的值 
           end%j
    %        f_value = feval(f,x);%计算蚂蚁当前位置的左区间对应的值
             f_value = F1(x);%!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
           %% 
           if f_value < fx_best
               % 更新节点信息量
               for j= 1:N_vars
                   tao(pos(j),j) = (1-Rou)*tao(pos(j),j)+Q/f_value;
               end %j
               % 计算信息量总和
               for j = 1:N_vars
                       tao_sum(j) =  sum(tao(:,N_vars));
    %                  tao_sum(j) =  sum(tao(:,N_vars).^index);
               end%j
               %% 更新概率
               for j = 1:N+1
                   for k = 1:N_vars
                      P(j,k) = tao(j,k) /tao_sum(k);
    %                   P(j,k) = tao(j,k)^index /tao_sum(k);
                   end%k
               end %j    
           end % end if
        end
           %% 通过概率的大小选择最优的变量和最优的函数值
           for j = 1:N_vars
               P_vars = P(:,j);%第j个变量的所有区间概率
               [P_x_best,ind] = sort(P_vars);%当前变量各个区间概率从小到大排序 ind 是对应概率的节点序号
               maxP_ind (j) = ind(N+1);%概率最大的节点序号=ind最后一个数 
               x_best(j) = Lower(j)+(Upper(j)-Lower(j))*(ind(N+1))/N;%计算最大概率变量的值
           end %j
    %        f_value = feval(f,x_best);%计算函数值
           f_value = F1(x_best);%!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
           if f_value < fx_best %更新最佳函数值
               fx_best = f_value;
               x_best = x;
           end
           optimal_f(iter) = fx_best
           optimal_x(iter,:) = x_best
           %% 缩小变量范围 优化变量范围
           for j = 1:N_vars
               Lower_new(j) = Lower(j)+(maxP_ind(j)-det)*((Upper(j)-Lower(j))/N);
               Upper_new(j) = Lower(j)+(maxP_ind(j)+det)*((Upper(j)-Lower(j))/N);
               % 越界处理
               if Lower_new(j)<Lower(j)
                   Lower_new(j)=Lower(j);
               end
               if Upper_new(j) > Upper(j)
                   Upper_new(j) = Upper(j);
               end
               Lower(j) = Lower_new(j);
               Upper(j) = Upper_new(j);
           end %j


        end %i   
     
    fx_best
    x_best
    figure(1)%变量的变化趋势
    for k = 1:N_vars
         subplot(N_vars,1,k);
         plot([1:Times],optimal_x(:,k),'b')
    end
    figure (2) %函数值的变化趋势
    plot ([1:Times],optimal_f,'b-')
      虽然是小小的程序,解决一些简单的函数求解 但是也是我科研的突破 嘿嘿,很开心
                
                
                
    展开全文
  • Matlab中蚁群算法求解连续函数优化的原程序-蚁群算法连续函数优化问题matlab程序.rar 蚁群算法求解连续函数优化的原程序 所含文件: Figure41.jpg 蚁群算法连续函数优化问题matlab程序
  • 蚁群算法;算法背景;PowerPoint 演示文稿;PowerPoint 演示文稿;PowerPoint 演示文稿;蚁群算法原理;蚁群算法原理;简化的蚂蚁寻食过程;简化的蚂蚁寻食过程;...连续蚁群算法;PowerPoint 演示文稿;蚁群优化
  • 智能算法之蚁群算法;蚁群算法原理;蚁群算法原理;简化的蚂蚁寻食过程 ;...连续蚁群算法; 蚁群优化算法参考书1; 蚁群算法参考书2;此课件下载可自行编辑修改仅供参考 感谢您的支持我们努力做得更好谢谢
  • 连续蚁群算法

    2011-10-22 12:31:42
    这是一个连续域的蚁群算法,界面友好,便于操作,里面有逆波兰转换代码。
  • 简要介绍了蚁群算法,并从解决连续域问题的角度分析了段海滨等提出的基于网格划分策略的连续蚁群算法的基本原理,针对该算法的特点和存在的缺陷,提出了改进的办法:在前期用遗传算法快速生成初始信息素,再利用...
  • 将变量为离散型的蚁群算法扩展到连续型变量,根据Socha, Krzysztof 和Dorigo, Marco在2008年发表的文章Ant colony optimization for continuous domains制作,内附原文及代码。
  • 为了用蚁群算法来解决连续优化问题 ,该算法将 函数优化问题 中生成解的过程转化为蚁群每前进一步就选择一个 十进制数字并以此来生成一个十进制串的过程。与普通蚁群算法相同,蚁群在选择数字的过程 中将一定量的...
  • 借鉴蚁群算法的进化思想, 提出一种求解连续空间优化问题的蚁群算法。该算法主要包括全局 搜索、 局部搜索和信息素强度更新规则。在全局搜索过程中, 利用信息素强度和启发式函数确定蚂蚁移 动方向。在局部...
  • matlab实现 连续蚁群算法aco 优化实现 信息素寻优+全局经验最优寻优
  • 扩展蚁群算法蚁群算法创始人 Dorigo提出的一种用于求解连续空间优化问题的最新蚁群算法,但该算法的收敛速度参数和局部搜索参数取值缺乏理论指导,因此其性能受算法参数影响较大。本文提出一种求解连续空间优化的...
  • 这是一个蚁群算法最原始的代码,对于刚刚学习蚁群算法的小萌新会很有帮助的。我最开始学习蚁群算法就是从这个算法开始的,针对连续域空间寻优很有帮助。
  • 基于常规蚁群算法进行了数学模型的构建、算法结构分析,并采用残留信息素数量限制、信息素的持久性系数自适应控制和全局更新规则对算法进行了加强设计,提出了双参数交叉影响的连续域组合优化蚁群算法;同时通过选取...
  • 受自然界蚂蚁的觅食-返巢生物学特征启发, 同时深入了解蚂蚁信息素成分, 提出了一种能够解决函数多目标优化问题的改进蚁群算法——多目标觅食-返巢机制连续蚁群算法MO-FHACO。MO-FHACO算法与传统蚁群算法相比, 将...
  • 为了克服基本蚁群算法搜索时间过长,易陷于局部最优等缺点。引入了随机算法,并提出了一种采用随机模式调整信息素的改进蚁群算法RACA(Randomized ...运算结果表明新的蚁群算法对求解连续函数优化问题有较好的改进效果。
  • 改进蚁群算法求解连续空间优化问题代码
  • 针对蚁群优化(ACO)只适用于离散问题的局限性,提出了连续蚁群优化算法(CACO),保留了连续问题可行解的原有形式,并融入演化算法(EA)的种群与操作功能。CACO将蚁群分工为全局和局部蚂蚁,分别引领个体执行全局...
  • 蚁群算法引入连续空间的函数寻优问题求解, 通过将传统蚁群算法中的“信息量留存”过程 拓展为连续空间中的“信息量分布函数”, 定义了相应的求解算法。对多极值函数和非线性连续函数的寻 优实例仿真取得...
  • 连续空间优化问题蚁群算法实现,用matlab实现,可运行,一个.m文件
  • 基于基本蚁群算法解决连续优化问题

    千次阅读 热门讨论 2018-04-18 02:10:09
    基于基本蚁群算法解决连续优化问题 相关链接 TSP_旅行商问题-基本蚁群算法 基本蚁群算法解决连续优化问题基本流程 用一个蚂蚁代表一个可行解,一个蚂蚁含有的信息包括各变量值; 1、确定迭代周期; 2、...

    基于基本蚁群算法解决连续优化问题

    相关链接

    TSP_旅行商问题-基本蚁群算法

    基本蚁群算法解决连续优化问题基本流程

    用一个蚂蚁代表一个可行解,一个蚂蚁含有的信息包括各变量值;
    1、确定迭代周期;
    2、确定蚂蚁数;
    2.a、随机初始化蚁群,记录蚁群中的最优解;
    2.b、进入循环,将已初始化的蚂蚁分为两种;
    2.b.a、一种是上一次蚁群中的最优解,搜索在最优解附近搜索;
    可行解格式{1自变量12自变量2n自变量n}
    X={x1x1x2x2xnxn}

    xi=xi+ωLxi=xi+ω∗L

    xi=xiωLxi=xi−ω∗L
    择优录取吧,每次循环后,ωω要变小;
    2.b.b、另一种是非最优解,有一定概率向最优解进化;
    P=emessbestmessiemessbestP=emessbest−messiemessbest

    messbestmessbest最优解蚂蚁的信息素浓度;
    messimessi当前蚂蚁的信息素浓度;
    2.b.b.a、向最优解移动:
    xi=xi+u(xbestxi)xi=xi+u∗(xbest−xi)

    2.b.b.b、自己搜索移动:
    xi=xi+dxrand(1,1)xi=xi+dx∗rand(−1,1)

    2.c、更新信息素
    messi=(1p)messi+kaf(X)messi=(1−p)∗messi+k∗a−f(X)

    参数设置

    最大迭代周期 T = 200;
    蚂蚁数量 ant_size = 25;
    信息素衰退因子 p = 0.9;
    步长系数 ωω = 1,随着迭代的进行变小
    步长系数减小因数 wu = 0.5;该数值越大,搜的范围越精细;
    最优解搜索步长 dx[max_x]:一般为自变量取值范围的一半;防止局部最优解;
    更新信息素系数 k = 1;
    更新信息素因子 a;求最小值时a取e;求最大值时a取0.5;
    非最优解步长系数 u = 0.7;
    非最优解向最优解进化概率 p0 = 0.7;

    本算法的fun()函数里包含三个求最小值样例;
    三个return分别代表三个函数

    • 函数一:二维分段函数,自变量范围[-5,5]

      f()={x2,x<=1;(x3)23,x>1;f()={x2,x<=1;(x−3)2−3,x>1;

      图像:
      这里写图片描述
      10组测试结果:
      这里写图片描述
    • 函数二:二维复杂函数,自变量范围[-5,5]

      f()=x+10sin(5x)+7cos(4x)f()=x+10∗sin(5∗x)+7∗cos(4∗x)

      图像:
      这里写图片描述
      10组测试结果:
      这里写图片描述
    • 函数三:三维函数,自变量x0x0范围[-10,10],x1x1范围[-10,10];

      f()=x01+abs(x1)f()=x01+abs(x1)

      图像:
      这里写图片描述
      10组测试结果:
      这里写图片描述

    算法代码

    #include<iostream>
    #include<ctime>
    #include<cmath>
    #include<fstream>
    #include<algorithm>
    #include<string.h>
    #include<iomanip>
    using namespace std;
    //常量
    const int max_x = 10;//自变量规模最大值
    const int max_ants = 1000;//蚂蚁规模最大值
    //变量
    int x_size;//自变量规模
    int low_bound[max_x];//自变量下界
    int high_bound[max_x];//自变量上界
    int ant_size=5;//蚂蚁数量
    int T;//迭代周期
    double message[max_ants];//信息素
    double w;//步长系数,随着迭代的进行变小
    double wu;//步长系数减小因数
    double dx[max_x];//最优解搜索步长
    double k;//更新信息素系数
    double a;//更新信息素因子
    double u;//非最优解步长系数
    double p0;//非最优解向最优解进化概率
    double p;//信息素衰减系数
    double best_ants[max_x];//最优解对应自变量值
    double best;//最优解
    double fun(double* num){//求解函数
    
        return num[0] <= 1 ? pow(num[0], 2) : (pow(num[0] - 3, 2) - 3);
        //return num[0] + 10 * sin(5 * num[0]) + 7 * cos(4 * num[0]);
        //return num[0] / (1 + abs(num[1]));
    }
    void init() {
        x_size=1;//自变量规模
        for (int i = 0; i < x_size; ++i) {
            low_bound[i] = -5;//自变量下界
            high_bound[i]=5;//自变量上界
            dx[i]=high_bound[i]-low_bound[i];//最优解搜索步长,,一般为数据范围的一半
        }
        T = 200;//迭代周期
        ant_size = 25;//蚂蚁数量
    
        w=1;//最优解步长系数,随着迭代的进行变小
        wu = 0.5;
        k=1;//更新信息素系数
        //a=exp(1);//更新信息素因子
        a = 0.5;///////////////
        p0 = 0.7;//非最优解向最优解进化概率
        u=0.7;//非最优解步长系数
        p=0.9;//信息素衰减系数
        //best =1e9;
        best = -1e9;
    }
    
    double mrand(int l, int r) {//范围在20内
        int t = l;
        r -= l;
        l -= l;
        const double v = 1e3;
        r *= v;
        l *= v;
        double temp = rand() % ((r - l) + 1);
        //int a = RAND_MAX;
        temp += 1 + l;
        return temp / v+t;
        //return (rand() % ((r - l) + 1) + 1 + l)/1e6;
    }
    double get_p(int i, int bes) {
        return exp(message[bes] - message[i]) / exp(message[bes]);
    }
    void islegal(double* xi) {
        for (int i = 0; i < x_size; ++i) {
            if (xi[i] > high_bound[i])
                xi[i]=high_bound[i];
            else if(xi[i] < low_bound[i])
                xi[i] = low_bound[i];
        }
    }
    //max
    /*
    void moni() {
        a = 0.5;///
        best = -1e9;
        double t_ants[max_ants][max_x];//蚁群
        double value[max_ants];//
        double ans = best;//
        int t_ant;//局部最优解
        for (int i = 0; i < ant_size; ++i) {
            for (int j = 0; j < x_size; ++j) {
                t_ants[i][j] = mrand(low_bound[j], high_bound[j]);
            }
            value[i] = fun(t_ants[i]);
            if (ans < value[i]) {/
                ans = value[i];
                t_ant = i;
            }
            message[i] = k * pow(a, -fun(t_ants[i]));//信息素初始化
        }
        int t = T;
        double x1[max_x];//构建临时解
        double x2[max_x];
    
        while (t--) {//开始迭代循环
            for (int i = 0; i<ant_size; ++i) {//更新信息素
                //message[i] = (1-p) * message[i] + t_mess[i];
                //message[i] = (1 - p) * message[i] + k * pow(a, -fun(t_ants[t_ant]));
                message[i] = (1 - p) * message[i];
            }
            double tw = w;
            for (int i = 0; i<ant_size; ++i) {//遍历每只蚂蚁
                if (value[i] == ans) {//上次循环最优解
                    for (int j = 0; j < x_size; ++j) {
                        x1[j] = t_ants[i][j] + tw * dx;
                        x2[j] = t_ants[i][j] - tw * dx;
                    }
                    tw *= 0.1; 
                    islegal(x1);
                    if (value[i] < fun(x1)) {//
                        value[i] = fun(x1);
                        ans = value[i];
                        t_ant = i;
                        for (int j = 0; j < x_size; ++j) {
                            t_ants[i][j] = x1[j];
                        }
                    }
                    islegal(x2);
                    if (value[i] < fun(x2)) {///
                        value[i] = fun(x2);
                        ans = value[i];
                        t_ant = i;
                        for (int j = 0; j < x_size; ++j) {
                            t_ants[i][j] = x2[j];
                        }
                    }
                }
                else {//非最优解
                    if (get_p(i, ans)<p0) {//向最优解移动
                        for (int j = 0; j < x_size; ++j) {
                            x1[j] = t_ants[i][j] + u * (t_ants[t_ant][j] - t_ants[i][j]);
                        }
                    }
                    else {
                        for (int j = 0; j < x_size; ++j) {
                            x1[j] = t_ants[i][j] + dx * mrand(-1, 1);
                        }
                    }
                    islegal(x1);
                    if (ans < fun(x1)) {//
                        ans = fun(x1);
                        value[i] = ans;
                        t_ant = i;
                        for (int j = 0; j < x_size; ++j)
                            t_ants[i][j] = x1[j];
                    }
                }
                //t_mess[i] += k * pow(a, -ans);
                message[i] += k * pow(a, -fun(t_ants[i]));
            }
            //
            //for (int i = 0; i<ant_size; ++i) {//更新信息素
                //message[i] = (1-p) * message[i] + t_mess[i];
                //message[i] = (1 - p) * message[i] + k * pow(a, -fun(t_ants[t_ant]));
            //}
            //ans = min(ans,t_ans);
        }
        for (int i = 0; i < x_size; ++i) {
            best_ants[i] = t_ants[t_ant][i];
        }
        best = ans;
    }
    */
    void moni() {//min
    
        a=exp(1);//更新信息素因子
        best = 1e9;
        double t_ants[max_ants][max_x];//蚁群
        double value[max_ants];//
        double ans = best;//
        int t_ant;//局部最优解
        for (int i = 0; i < ant_size; ++i) {
            for (int j = 0; j < x_size; ++j) {
                t_ants[i][j] = mrand(low_bound[j], high_bound[j]);
            }
            value[i] = fun(t_ants[i]);
            if (ans > value[i]) {/////////
                ans = value[i];
                t_ant = i;
            }
            message[i] = k * pow(a, -fun(t_ants[i]));//信息素初始化
        }
        int t = T;
        double x1[max_x];//构建临时解
        double x2[max_x];
    
        while (t--) {//开始迭代循环
            for (int i = 0; i<ant_size; ++i) {//更新信息素
                //message[i] = (1-p) * message[i] + t_mess[i];
                //message[i] = (1 - p) * message[i] + k * pow(a, -fun(t_ants[t_ant]));
                message[i] = (1 - p) * message[i];
            }
            double tw = w;
            for (int i = 0; i<ant_size; ++i) {//遍历每只蚂蚁
                if (value[i] == ans) {//上次循环最优解
                    for (int j = 0; j < x_size; ++j) {
                        x1[j] = t_ants[i][j] + tw * dx[j];
                        x2[j] = t_ants[i][j] - tw * dx[j];
                    }
                    tw *= wu; 
                    islegal(x1);
                    if (value[i] > fun(x1)) {//////////////
                        value[i] = fun(x1);
                        ans = value[i];
                        t_ant = i;
                        for (int j = 0; j < x_size; ++j) {
                            t_ants[i][j] = x1[j];
                        }
                    }
                    islegal(x2);
                    if (value[i] > fun(x2)) {///////////////
                        value[i] = fun(x2);
                        ans = value[i];
                        t_ant = i;
                        for (int j = 0; j < x_size; ++j) {
                            t_ants[i][j] = x2[j];
                        }
                    }
                }
                else {//非最优解
                    if (get_p(i, ans)<p0) {//向最优解移动
                        for (int j = 0; j < x_size; ++j) {
                            x1[j] = t_ants[i][j] + u * (t_ants[t_ant][j] - t_ants[i][j]);
                        }
                    }
                    else {
                        for (int j = 0; j < x_size; ++j) {
                            x1[j] = t_ants[i][j] + dx[j] * mrand(-1, 1);
                        }
                    }
                    islegal(x1);
                    if (ans > fun(x1)) {//////////////
                        ans = fun(x1);
                        value[i] = ans;
                        t_ant = i;
                        for (int j = 0; j < x_size; ++j)
                            t_ants[i][j] = x1[j];
                    }
                }
                //t_mess[i] += k * pow(a, -ans);
                message[i] += k * pow(a, -fun(t_ants[i]));
            }
            //
            //for (int i = 0; i<ant_size; ++i) {//更新信息素
                //message[i] = (1-p) * message[i] + t_mess[i];
                //message[i] = (1 - p) * message[i] + k * pow(a, -fun(t_ants[t_ant]));
            //}
            //ans = min(ans,t_ans);
        }
        for (int i = 0; i < x_size; ++i) {
            best_ants[i] = t_ants[t_ant][i];
        }
        best = ans;
    }
    void output() {
        for (int i = 0; i < x_size; ++i) {
            cout << "x" << i << " = " << best_ants[i];
            if (i != x_size - 1)
                cout << " , ";
            else
                cout << endl;
        }
        cout <<fixed<< "f() = " << best << endl;
        cout.clear();
    }
    int main() {
        srand(time(nullptr));
        int t;
        while (cin >> t) {//仅作为重启算法开关使用,无意义
            //for (int i = 0; i < t; ++i) {
                init();//使用程序内置数据使用init()函数,
                       //test();//使用文件读取数据使用test()函数
                moni();//开始算法
                output();//输出
            //}
        }
        return 0;
    }
    展开全文
  • 借鉴蚁群算法的进化思想,提出一种求解连续空问优化问题的蚁群算法。该算法主要包括全局搜索、局部搜索和信忠素强度更新规则。在全局搜索过程中,利用信忠素强度和启发武函数确定蚂蚁移动方向。在局部搜索过程中,...
  • 以现有的喷射器实验数据集作为样本,用单隐层前向神经网络预测喷射器的性能,网络的训练分别采用连续蚁群系(CACS)算法和连续蚁群优化(ACOR)算法.数值实验结果显示,用这两种蚁群算法所训练的神经网络对于喷射器性能...
  • 蚁群算法主要应用于组合优化问题,这里给出其在连学优化问题中的实现
  • 蚁群算法引入连续空间的函数寻优问题求解,通过将传统蚁群算法中的“信忠量留存”过程拓展为连续空间中的“信息量分布函数”,定义了相应的求解算法。对多极值函数和非线性连续函数的寻优实例仿真取得了良好的结果...
  • 对于基本蚁群算法(ACA)不适用求解连续空间问题,并且极易陷入局部最优的缺点,提出了一种基于自适应的蚁群算法。路径搜索策略采用基于目标函数值搜索筛选局部最优解的策略,确保能够迅速找到可行解。信息素更新...
  • MATLAB源码集锦-改进蚁群算法求解连续空间优化问题代码
  • 在位姿误差模型的基础上,利用基于网格划分策略的连续蚁群算法,通过信息素更新指导蚂蚁反复搜索,对驱动杆杆长误差进行寻优,最终补偿Stewart 并联机器人位姿误差。数值仿真结果表明,该方法是有效的。
  • 蚁群算法的研究

    2014-09-13 22:07:37
    蚁群算法一圈已签收已签基于连续型函数的蚁群算法的研究
  • 论文研究-蚁群算法进行连续参数优化的新途径.pdf, 提出用蚁群算法进行连续参数优化的一种方法 .该方法对解的每一个分量的可能的取值组成一个动态的候选组 ,并对候选组中...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 151
精华内容 60
关键字:

连续蚁群算法