13基于蚁群算法的连续函数优化通用MATLAB源代码

一、引言随着科技的不断发展，各种电子设备在我们的生活中起着越来越重要的作用。

然而，这些电子设备在长时间的使用过程中难免会出现故障，而故障的及时准确诊断对于设备的正常运行和维护至关重要。

故障诊断技术的研究和应用显得尤为重要。

二、故障诊断方法的研究现状1.基于蚁群算法的故障诊断方法蚁群算法是一种通过模拟蚂蚁在寻找食物过程中留下的信息素路径来解决组合优化等计算问题的启发式算法。

近年来，蚁群算法在故障诊断领域得到了广泛的应用。

其优点在于能够充分利用信息素路径的思想，通过不断搜索最优解的方式，找到最适合的故障诊断方案。

2.传统的故障诊断方法传统的故障诊断方法多为基于专家系统或规则库的方式，需要事先对设备的故障类型和规律进行深入的研究和积累。

在实际应用中存在诊断效率低、难以适应复杂环境的问题。

三、基于蚁群算法的故障诊断代码实现1. 蚁群算法的原理蚁群算法是一种模拟蚂蚁在寻找食物过程中留下信息素路径的算法，通过信息素路径的不断蒸发和更新，最终寻找到最优的路径。

在故障诊断中，可以将设备的故障模式看作“食物”，蚂蚁的行走路径看作“诊断路径”，通过模拟蚂蚁在搜索食物的过程中留下信息素路径的方式，来寻找最优的故障诊断路径。

2.算法流程（1）初始化信息素和蚂蚁的位置；（2）蚂蚁根据信息素浓度选择下一步的行走方向；（3）蚂蚁行走后更新信息素浓度；（4）重复步骤（2）和（3），直到所有蚂蚁都找到故障诊断路径；（5）根据信息素浓度更新蚂蚁的行走路径。

3.代码实现以MATLAB为例，基于蚁群算法的故障诊断代码可以通过以下步骤实现：（1）初始化信息素和蚂蚁的位置，设定设备故障模式和规则库；（2）根据信息素浓度和故障规则，确定蚂蚁下一步的行走路径；（3）蚂蚁行走后更新信息素浓度；（4）重复步骤（2）和（3），直到所有蚂蚁都找到故障诊断路径；（5）根据信息素浓度更新蚂蚁的行走路径，最终得到最优的故障诊断路径。

四、代码优化与应用1. 参数调优在实际编写故障诊断代码时，需要针对具体的设备和故障情况进行参数的调优，以保证算法的高效性和准确性。

蚁群算法代码在⽹上看了⼀些蚁群算法原理，其中最为⼴泛的应⽤还是那个旅⾏家问题（TSP）。

诸如粒⼦群优化算法，蚁群算法都可以求⼀个⽬标函数的最⼩值问题的。

下⾯代码记录下跑的代码。

蚁群算法中最为重要的就是⽬标函数和信息素矩阵的设计。

其他的参数则为信息素重要程度，信息素挥发速度，适应度的重要程度。

import numpy as npfrom scipy import spatialimport pandas as pdimport matplotlib.pyplot as plt'''test Ant Aolony Algorithm'''num_points = 25points_coordinate = np.random.rand(num_points, 2) # generate coordinate of pointsdistance_matrix = spatial.distance.cdist(points_coordinate, points_coordinate, metric='euclidean')# routine 中应该为⼀个列表，其中存放的是遍历过程中的位置编号def cal_total_distance(routine):num_points, = routine.shapereturn sum([distance_matrix[routine[i % num_points], routine[(i + 1) % num_points]] for i in range(num_points)])# %% Do ACAfrom sko.ACA import ACA_TSP'''需要设置的参数包含以下部分:(1): ⽬标函数: ⽤于衡量之前⾛过的的路径的⽬标值（累计路程值）, 需要有⼀个参数routine, ⽤于记录遍历的路径位置索引(2): 维度数⽬: 此数字将被⽤于程序进⾏构建遍历路径位置索引(3): 蚁群数⽬: size_pop(4): 最⼤迭代次数: 作为⼀项中值条件(5): 距离(⾪属度/信息素)矩阵: 蚁群算法中⼀般称其为信息素矩阵，需要预先进⾏计算，旨在记录两个路径点之间的距离长度[注意]: 距离矩阵在输⼊之前需要进⾏计算缺点: 速度太慢'''aca = ACA_TSP(func=cal_total_distance, n_dim=num_points,size_pop=500, max_iter=200,distance_matrix=distance_matrix)best_x, best_y = aca.run()# %% Plotfig, ax = plt.subplots(1, 2)best_points_ = np.concatenate([best_x, [best_x[0]]])best_points_coordinate = points_coordinate[best_points_, :]ax[0].plot(best_points_coordinate[:, 0], best_points_coordinate[:, 1], 'o-r')pd.DataFrame(aca.y_best_history).cummin().plot(ax=ax[1])plt.show()。

30个智能算法matlab代码以下是30个使用MATLAB编写的智能算法的示例代码： 1. 线性回归算法：matlab.x = [1, 2, 3, 4, 5];y = [2, 4, 6, 8, 10];coefficients = polyfit(x, y, 1);predicted_y = polyval(coefficients, x);2. 逻辑回归算法：matlab.x = [1, 2, 3, 4, 5];y = [0, 0, 1, 1, 1];model = fitglm(x, y, 'Distribution', 'binomial'); predicted_y = predict(model, x);3. 支持向量机算法：matlab.x = [1, 2, 3, 4, 5; 1, 2, 2, 3, 3];y = [1, 1, -1, -1, -1];model = fitcsvm(x', y');predicted_y = predict(model, x');4. 决策树算法：matlab.x = [1, 2, 3, 4, 5; 1, 2, 2, 3, 3]; y = [0, 0, 1, 1, 1];model = fitctree(x', y');predicted_y = predict(model, x');5. 随机森林算法：matlab.x = [1, 2, 3, 4, 5; 1, 2, 2, 3, 3]; y = [0, 0, 1, 1, 1];model = TreeBagger(50, x', y');predicted_y = predict(model, x');6. K均值聚类算法：matlab.x = [1, 2, 3, 10, 11, 12]; y = [1, 2, 3, 10, 11, 12]; data = [x', y'];idx = kmeans(data, 2);7. DBSCAN聚类算法：matlab.x = [1, 2, 3, 10, 11, 12]; y = [1, 2, 3, 10, 11, 12]; data = [x', y'];epsilon = 2;minPts = 2;[idx, corePoints] = dbscan(data, epsilon, minPts);8. 神经网络算法：matlab.x = [1, 2, 3, 4, 5];y = [0, 0, 1, 1, 1];net = feedforwardnet(10);net = train(net, x', y');predicted_y = net(x');9. 遗传算法：matlab.fitnessFunction = @(x) x^2 4x + 4;nvars = 1;lb = 0;ub = 5;options = gaoptimset('PlotFcns', @gaplotbestf);[x, fval] = ga(fitnessFunction, nvars, [], [], [], [], lb, ub, [], options);10. 粒子群优化算法：matlab.fitnessFunction = @(x) x^2 4x + 4;nvars = 1;lb = 0;ub = 5;options = optimoptions('particleswarm', 'PlotFcn',@pswplotbestf);[x, fval] = particleswarm(fitnessFunction, nvars, lb, ub, options);11. 蚁群算法：matlab.distanceMatrix = [0, 2, 3; 2, 0, 4; 3, 4, 0];pheromoneMatrix = ones(3, 3);alpha = 1;beta = 1;iterations = 10;bestPath = antColonyOptimization(distanceMatrix, pheromoneMatrix, alpha, beta, iterations);12. 粒子群-蚁群混合算法：matlab.distanceMatrix = [0, 2, 3; 2, 0, 4; 3, 4, 0];pheromoneMatrix = ones(3, 3);alpha = 1;beta = 1;iterations = 10;bestPath = particleAntHybrid(distanceMatrix, pheromoneMatrix, alpha, beta, iterations);13. 遗传算法-粒子群混合算法：matlab.fitnessFunction = @(x) x^2 4x + 4;nvars = 1;lb = 0;ub = 5;gaOptions = gaoptimset('PlotFcns', @gaplotbestf);psOptions = optimoptions('particleswarm', 'PlotFcn',@pswplotbestf);[x, fval] = gaParticleHybrid(fitnessFunction, nvars, lb, ub, gaOptions, psOptions);14. K近邻算法：matlab.x = [1, 2, 3, 4, 5; 1, 2, 2, 3, 3]; y = [0, 0, 1, 1, 1];model = fitcknn(x', y');predicted_y = predict(model, x');15. 朴素贝叶斯算法：matlab.x = [1, 2, 3, 4, 5; 1, 2, 2, 3, 3]; y = [0, 0, 1, 1, 1];model = fitcnb(x', y');predicted_y = predict(model, x');16. AdaBoost算法：matlab.x = [1, 2, 3, 4, 5; 1, 2, 2, 3, 3];y = [0, 0, 1, 1, 1];model = fitensemble(x', y', 'AdaBoostM1', 100, 'Tree'); predicted_y = predict(model, x');17. 高斯混合模型算法：matlab.x = [1, 2, 3, 4, 5]';y = [0, 0, 1, 1, 1]';data = [x, y];model = fitgmdist(data, 2);idx = cluster(model, data);18. 主成分分析算法：matlab.x = [1, 2, 3, 4, 5; 1, 2, 2, 3, 3]; coefficients = pca(x');transformed_x = x' coefficients;19. 独立成分分析算法：matlab.x = [1, 2, 3, 4, 5; 1, 2, 2, 3, 3]; coefficients = fastica(x');transformed_x = x' coefficients;20. 模糊C均值聚类算法：matlab.x = [1, 2, 3, 4, 5; 1, 2, 2, 3, 3]; options = [2, 100, 1e-5, 0];[centers, U] = fcm(x', 2, options);21. 遗传规划算法：matlab.fitnessFunction = @(x) x^2 4x + 4; nvars = 1;lb = 0;ub = 5;options = optimoptions('ga', 'PlotFcn', @gaplotbestf);[x, fval] = ga(fitnessFunction, nvars, [], [], [], [], lb, ub, [], options);22. 线性规划算法：matlab.f = [-5; -4];A = [1, 2; 3, 1];b = [8; 6];lb = [0; 0];ub = [];[x, fval] = linprog(f, A, b, [], [], lb, ub);23. 整数规划算法：matlab.f = [-5; -4];A = [1, 2; 3, 1];b = [8; 6];intcon = [1, 2];[x, fval] = intlinprog(f, intcon, A, b);24. 图像分割算法：matlab.image = imread('image.jpg');grayImage = rgb2gray(image);binaryImage = imbinarize(grayImage);segmented = medfilt2(binaryImage);25. 文本分类算法：matlab.documents = ["This is a document.", "Another document.", "Yet another document."];labels = categorical(["Class 1", "Class 2", "Class 1"]);model = trainTextClassifier(documents, labels);newDocuments = ["A new document.", "Another new document."];predictedLabels = classifyText(model, newDocuments);26. 图像识别算法：matlab.image = imread('image.jpg');features = extractFeatures(image);model = trainImageClassifier(features, labels);newImage = imread('new_image.jpg');newFeatures = extractFeatures(newImage);predictedLabel = classifyImage(model, newFeatures);27. 时间序列预测算法：matlab.data = [1, 2, 3, 4, 5];model = arima(2, 1, 1);model = estimate(model, data);forecastedData = forecast(model, 5);28. 关联规则挖掘算法：matlab.data = readtable('data.csv');rules = associationRules(data, 'Support', 0.1);29. 增强学习算法：matlab.environment = rlPredefinedEnv('Pendulum');agent = rlDDPGAgent(environment);train(agent);30. 马尔可夫决策过程算法：matlab.states = [1, 2, 3];actions = [1, 2];transitionMatrix = [0.8, 0.1, 0.1; 0.2, 0.6, 0.2; 0.3, 0.3, 0.4];rewardMatrix = [1, 0, -1; -1, 1, 0; 0, -1, 1];policy = mdpPolicyIteration(transitionMatrix, rewardMatrix);以上是30个使用MATLAB编写的智能算法的示例代码，每个算法都可以根据具体的问题和数据进行相应的调整和优化。

群智能优化算法-测试函数matlab源码群智能优化算法测试函数matlab源代码global M;creatematrix(2);%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%画ackley图。

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ackley x from[-5 5]% x=-5:0.01:5;% [x,y]=meshgrid(x);% temp1=x.^2+y.^2;% temp2=cos(2*pi*x)+cos(2*pi*y);% z=20+exp(1)-20*exp(-0.2*sqrt(temp1/2))-exp(temp2/2);% axis([-5,5,-5,5]);% meshc(x,y,z);%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%画旋转的ackley图。

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%Rotated ackley x from[-5 5% x=-5:0.01:5;% [x,y]=meshgrid(x);% for i=1:size(x,1)% for j=1:size(y,1)% p=[x(i,j),y(i,j)]';% x(i,j)=M(1,:)*p;% y(i,j)=M(2,:)*p;% end% end% temp1=x.^2+y.^2;% temp2=cos(2*pi*x)+cos(2*pi*y);% z=20+exp(1)-20*exp(-0.2*sqrt(temp1/2))-exp(temp2/2);% axis([-5,5,-5,5]);% meshc(x,y,z);%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%画cigar图。

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cigarx=-5:0.01:5;[x,y]=meshgrid(x);z=x.^2+(10^4)*y.^2;axis([-5,5,-5,5]);meshc(x,y,z);%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%画旋转的cigar图。

其中，表示在t时刻蚂蚁k由元素（城市）i转移到元素（城市）j的状态转移概率。

allowedk = C − tabuk表示蚂蚁k下一步允许选择的城市。

α为启发式因子，表示轨迹的相对重要性，反映了蚂蚁在运动过程中所积累的信息在蚂蚁运动时所起的作用，其值越大，则该蚂蚁越倾向于选择其他蚂蚁经过的路径，蚂蚁之间的协作性越强。

β为期望启发式因子，表示能见度的相对重要性，反映了蚂蚁在运动过程中启发信息在蚂蚁选择路径中的受重视程度，其值越大，则该状态转移概率越接近于贪心规则；ηij(t) 为启发函数，表达式为。

式中，dij表示相邻两个城市之间的距离。

（6）修改禁忌表指针，即选择好之后将蚂蚁移动到新的元素（城市），并把该元素（城市）移动到该蚂蚁个体的禁忌表中。

（7）若集合C中元素（城市）未遍历完，即k<m，则跳转到第（4）步，否则执行第（8）步。

（8）根据公式更新每条路径上的信息量：τij(t + n) = (1 − ρ) * τij(t) + Δτij(t),（9）若满足结束条件，即如果循环次数，则循环结束并输出程序计算结果，否则清空禁忌表并跳转到第（2）步。

蚁群算法的matlab源程序1.蚁群算法主程序：main.m%function [bestroute,routelength]=AntClccleartic% 读入城市间距离矩阵数据文件CooCity = load( 'CooCity.txt' ) ;% 城市网络图坐标数据文件，txt形式给出NC=length(CooCity); % 城市个数for i=1:NC % 计算各城市间的距离for j=1:NCdistance(i,j)=sqrt((CooCity(i,2)-CooCity(j,2))^2+(CooCity(i,3)-CooCity(j,3))^2);endendMAXIT=10;%最大循环次数Citystart=[]; % 起点城市编号tau=ones(NC,NC); % 初始时刻各边上的信息痕迹为1rho=0.5; % 挥发系数alpha=1; % 残留信息相对重要度beta=5; % 预见值的相对重要度Q=10; % 蚁环常数NumAnt=20; % 蚂蚁数量routelength=inf; % 用来记录当前找到的最优路径长度for n=1:MAXITfor k=1:NumAnt %考查第K只蚂蚁deltatau=zeros(NC,NC); % 第K只蚂蚁移动前各边上的信息增量为零%[routek,lengthk]=path(distance,tau,alpha,beta,[]); % 不靠率起始点[routek,lengthk]=path(distance,tau,alpha,beta,Citystart); % 指定起始点if lengthk<routelength %找到一条更好的路径:::routelength=lengthk;:::bestroute=routek;endfor i=1:NC-1 % 第K只蚂蚁在路径上释放的信息量deltatau(routek(i),routek(i+1))=deltatau(routek(i),routek(i+1))+Q/lengthk; % 信息素更新end%deltatau(routek(NC),1)=deltatau(routek(NC),1)+Q/lengthk; %endlength_n(n)=routelength; % 记录路径收敛tau=(1-rho).*tau; % 信息素挥发end%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%costtime=toc;subplot(1,2,1),plot([CooCity(bestroute,2)],[CooCity(bestroute,3)],'-*')subplot(1,2,2),plot([1:MAXIT],length_n,'-*')[routelength,costtime]2.蚁群算法寻找路径程序：path.m% 某只蚂蚁找到的某条路径routek,lengthkfunction [routek,lengthk]=path(distance,tau,alpha,beta,Citystart)[m,n]=size(distance);if isempty(Citystart) % 如果不确定起点p=fix(m*rand)+1; % 随机方式初始化起点，均匀概率elsep=Citystart; % 外部给定确定起点 endlengthk=0; % 初始路径长度设为 0routek=[p]; % 蚂蚁路径点序列，即该蚂蚁已经过的城市集合，路径初始起点for i=1:m-1np=routek(end); % 蚂蚁路径城市序号，依次经过的城市编号np_sum=0; % 路由长度初始为 0for j=1:mif inroute(j,routek) % 判断城市节点j是否属于tabuk，即是否已经过continue;else % j为还未经过的点ada=1/distance(np,j); % 预见度np_sum=np_sum+tau(np,j)^alpha*ada^beta; % 路由表：信息痕迹、预见度 endendcp=zeros(1,m); % 转移概率，基于路径长度及路由表for j=1:mifinroute(j,routek)continue;elseada=1/distance(np,j); % 预见度cp(j)=tau(np,j)^alpha*ada^beta/np_sum; % np到j的转移概率endendNextCity=nextcitychoose2(cp); % 根据转移概率确定下一个城市,% 直观地，取转移概率最大值方向方法，决策结果稳定且收敛快routek=[routek,NextCity]; % 更新路径lengthk=lengthk+distance(np,NextCity); % 更新路径长度end蚁群算法仿真结果:其中左边是蚂蚁行走的最短路径，右边是最短路径的值的收敛情况。

matlab-蚁群算法-机器人路径优化问题4.1问题描述移动机器人路径规划是机器人学的一个重要研究领域。

它要求机器人依据某个或某些优化原则(如最小能量消耗，最短行走路线，最短行走时间等)，在其工作空间中找到一条从起始状态到目标状态的能避开障碍物的最优路径。

机器人路径规划问题可以建模为一个有约束的优化问题，都要完成路径规划、定位和避障等任务。

4.2算法理论蚁群算法（AntColonyAlgorithm，ACA），最初是由意大利学者DorigoM.博士于1991年首次提出，其本质是一个复杂的智能系统，且具有较强的鲁棒性，优良的分布式计算机制等优点。

该算法经过十多年的发展，已被广大的科学研究人员应用于各种问题的研究，如旅行商问题，二次规划问题，生产调度问题等。

但是算法本身性能的评价等算法理论研究方面进展较慢。

Dorigo提出了精英蚁群模型（EAS），在这一模型中信息素更新按照得到当前最优解的蚂蚁所构造的解来进行，但这样的策略往往使进化变得缓慢，并不能取得较好的效果。

次年Dorigo博士在文献[30]中给出改进模型（ACS），文中改进了转移概率模型，并且应用了全局搜索与局部搜索策略，来得进行深度搜索。

Stützle与Hoo给出了最大-最小蚂蚁系统（MA某-MINAS），所谓最大-最小即是为信息素设定上限与下限，设定上限避免搜索陷入局部最优，设定下限鼓励深度搜索。

蚂蚁作为一个生物个体其自身的能力是十分有限的，比如蚂蚁个体是没有视觉的，蚂蚁自身体积又是那么渺小，但是由这些能力有限的蚂蚁组成的蚁群却可以做出超越个体蚂蚁能力的超常行为。

蚂蚁没有视觉却可以寻觅食物，蚂蚁体积渺小而蚁群却可以搬运比它们个体大十倍甚至百倍的昆虫。

这些都说明蚂蚁群体内部的某种机制使得它们具有了群体智能，可以做到蚂蚁个体无法实现的事情。

经过生物学家的长时间观察发现，蚂蚁是通过分泌于空间中的信息素进行信息交流，进而实现群体行为的。

遗传算法多目标优化matlab源代码遗传算法(Genetic Algorithm，GA)是一种基于自然选择和遗传学原理的优化算法。

它通过模拟生物进化过程，利用交叉、变异等操作来搜索问题的最优解。

在多目标优化问题中，GA也可以被应用。

本文将介绍如何使用Matlab实现遗传算法多目标优化，并提供源代码。

一、多目标优化1.1 多目标优化概述在实际问题中，往往存在多个冲突的目标函数需要同时优化。

这就是多目标优化(Multi-Objective Optimization, MOO)问题。

MOO不同于单一目标优化(Single Objective Optimization, SOO)，因为在MOO中不存在一个全局最优解，而是存在一系列的Pareto最优解。

Pareto最优解指的是，在不降低任何一个目标函数的情况下，无法找到更好的解决方案。

因此，在MOO中我们需要寻找Pareto前沿(Pareto Front)，即所有Pareto最优解组成的集合。

1.2 MOO方法常见的MOO方法有以下几种：（1）加权和法：将每个目标函数乘以一个权重系数，并将其加和作为综合评价指标。

（2）约束法：通过添加约束条件来限制可行域，并在可行域内寻找最优解。

（3）多目标遗传算法：通过模拟生物进化过程，利用交叉、变异等操作来搜索问题的最优解。

1.3 MOO评价指标在MOO中，我们需要使用一些指标来评价算法的性能。

以下是常见的MOO评价指标：（1）Pareto前沿覆盖率：Pareto前沿中被算法找到的解占总解数的比例。

（2）Pareto前沿距离：所有被算法找到的解与真实Pareto前沿之间的平均距离。

（3）收敛性：算法是否能够快速收敛到Pareto前沿。

二、遗传算法2.1 遗传算法概述遗传算法(Genetic Algorithm, GA)是一种基于自然选择和遗传学原理的优化算法。

它通过模拟生物进化过程，利用交叉、变异等操作来搜索问题的最优解。

Matlab优化算法以及应用案例分析引言Matlab是一款功能强大的数学软件，以其丰富的功能和灵活的编程环境而受到广泛的应用。

在数学建模和优化问题中，Matlab优化算法是一个重要的工具。

本文将介绍Matlab优化算法的基本原理和常见应用案例分析。

一、Matlab优化算法的基本原理1.1 最优化问题的定义在开始介绍优化算法之前，我们首先需要了解什么是最优化问题。

最优化问题可以定义为在一定的约束条件下，找到使得目标函数达到最大或者最小的变量取值。

最优化问题可以分为无约束问题和约束问题两种。

1.2 Matlab优化工具箱Matlab提供了丰富的优化工具箱，其中包含了许多优化算法的实现。

这些算法包括无约束优化算法、约束优化算法、全局优化算法等。

这些工具箱提供了简单易用的函数接口和丰富的算法实现，方便用户在优化问题中使用。

1.3 优化算法的分类优化算法可以分为传统优化算法和启发式优化算法两类。

传统优化算法包括梯度下降法、牛顿法、共轭梯度法等，它们利用目标函数的一阶或二阶导数信息进行搜索。

而启发式优化算法则通过模拟生物进化、遗传算法、蚁群算法等方法来进行搜索。

二、Matlab优化算法的应用案例分析2.1 无约束优化问题无约束优化问题是指在没有约束条件的情况下，找到使得目标函数达到最小或最大值的变量取值。

在Matlab中，可以使用fminunc函数来求解无约束优化问题。

下面以一维函数的最小化问题为例进行分析。

首先，我们定义一个一维的目标函数，例如f(x) = 3x^2 - 4x + 2。

然后使用fminunc函数来求解该问题。

代码示例：```matlabfun = @(x)3*x^2 - 4*x + 2;x0 = 0; % 初始点[x, fval] = fminunc(fun, x0);```在上述代码中，fun是目标函数的定义，x0是初始点的取值。

fminunc函数将返回最优解x和目标函数的最小值fval。

view plaincopy to clipboardprint?/**********************************作者:陈杰*单位:四川大学计算机学院*邮件地址:scucj@*完成时间:2008年3月*********************************/#include<iostream>#include<math.h>#include<time.h>using namespace std;//该程序是以蚁群系统为模型写的蚁群算法程序(强调：非蚂蚁周模型)，以三个著名的TSP 问题为测试对象//通过微调参数，都可以获得较好的解/*//----------(1)问题一：Oliver 30 城市TSP 问题best_length = 423.7406; ------------------------ //该程序最好的结果是423.741，可运行多次获得//城市节点数目#define N 30//城市坐标double C[N][2]={{2,99},{4,50},{7,64},{13,40},{18,54},{18,40},{22,60},{24,42},{25,62},{25,38},{37,84},{41,94},{41,26},{44,35},{45,21},{54,67},{54,62},{58,35},{58,69},{62,32},{64,60},{68,58},{71,44},{71,71},{74,78},{82,7},{83,46},{83,69},{87,76},{91,38}};//----------上面参数是固定的，下面的参数是可变的-----------//蚂蚁数量#define M 30//最大循环次数NcMaxint NcMax = 500;//信息启发因子，期望启发式因子，全局信息素挥发参数，局部信息素挥发参数, 状态转移公式中的q0double alpha = 2, beta = 3, rou = 0.1, alpha1 = 0.1, qzero = 0.01;//-----------问题一结束------------------------------------------------------------------------*//*//----------(2)问题二：Elion50 城市TSP 问题best_length = 427.96; ---------------------------- //该程序最好的结果是428.468，可运行多次获得//城市节点数目#define N 50//城市坐标double C[N][2]={{5,64}, {5,25}, {5,6}, {7,38}, {8,52}, {10,17},{12,42}, {13,13}, {16,57}, {17,33}, {17,63},{20,26}, {21,47}, {21,10}, {25,32}, {25,55},{27,68}, {27,23}, {30,48}, {30,15}, {31,62},{31,32}, {32,22}, {32,39}, {36,16}, {37,69},{37,52}, {38,46}, {39,10}, {40,30}, {42,57},{42,41}, {43,67}, {45,35}, {46,10}, {48,28},{49,49}, {51,21}, {52,33}, {52,41}, {52,64},{56,37}, {57,58}, {58,27}, {58,48}, {59,15},{61,33}, {62,42}, {62,63}, {63,69}};//----------上面参数是固定的，下面的参数是可变的-----------//蚂蚁数量#define M 50//最大循环次数NcMaxint NcMax = 1000;//信息启发因子，期望启发式因子，全局信息素挥发参数，局部信息素挥发参数, 状态转移公式中的q0double alpha = 2, beta = 4, rou = 0.1, alpha1 = 0.1, qzero = 0.01;//-----------问题二结束------------------------------------------------------------------------*///----------(3)问题三：Elion75 城市TSP 问题best_length = 542.31;//该程序最好的结果是542.309，可运行多次获得//城市节点数目#define N 75//城市坐标double C[N][2]={{6,25}, {7,43}, {9,56}, {10,70}, {11,28},{12,17}, {12,38}, {15,5}, {15,14}, {15,56},{16,19}, {17,64}, {20,30}, {21,48}, {21,45},{21,36}, {22,53}, {22,22}, {26,29}, {26,13},{26,59}, {27,24}, {29,39}, {30,50}, {30,20},{30,60}, {31,76}, {33,34}, {33,44}, {35,51},{35,16}, {35,60}, {36,6}, {36,26}, {38,33},{40,37}, {40,66}, {40,60}, {40,20}, {41,46},{43,26}, {44,13}, {45,42}, {45,35}, {47,66},{48,21}, {50,30}, {50,40}, {50,50}, {50,70},{50,4}, {50,15}, {51,42}, {52,26}, {54,38},{54,10}, {55,34}, {55,45}, {55,50}, {55,65},{55,57}, {55,20}, {57,72}, {59,5}, {60,15},{62,57}, {62,48}, {62,35}, {62,24}, {64,4},{65,27}, {66,14}, {66,8}, {67,41}, {70,64}};//----------上面参数是固定的，下面的参数是可变的-----------//蚂蚁数量#define M 75//最大循环次数NcMaxint NcMax =1000;//信息启发因子，期望启发式因子，全局信息素挥发参数，局部信息素挥发参数, 状态转移公式中的q0double alpha = 2, beta = 5, rou = 0.1, alpha1 = 0.1, qzero = 0.1;//-----------问题三结束------------------------------------------------------------------------//===================================================================== ======================================//局部更新时候使用的的常量，它是由最近邻方法得到的一个长度//什么是最近邻方法?:)就是从源节点出发，每次选择一个距离最短的点来遍历所有的节点得到的路径//每个节点都可能作为源节点来遍历double Lnn;//矩阵表示两两城市之间的距离double allDistance[N][N];//计算两个城市之间的距离double calculateDistance(int i, int j){return sqrt(pow((C[i][0]-C[j][0]),2.0) + pow((C[i][1]-C[j][1]),2.0));}//由矩阵表示两两城市之间的距离void calculateAllDistance(){for(int i = 0; i < N; i++){for(int j = 0; j < N; j++){if (i != j){allDistance[i][j] = calculateDistance(i, j);allDistance[j][i] = allDistance[i][j];}}}}//获得经过n个城市的路径长度double calculateSumOfDistance(int* tour){double sum = 0;for(int i = 0; i< N ;i++){int row = *(tour + 2 * i);int col = *(tour + 2* i + 1);sum += allDistance[row][col];}return sum;}class ACSAnt;class AntColonySystem{private:double info[N][N], visible[N][N];//节点之间的信息素强度,节点之间的能见度public:AntColonySystem(){}//计算当前节点到下一节点转移的概率double Transition(int i, int j);//局部更新规则void UpdateLocalPathRule(int i, int j);//初始化void InitParameter(double value);//全局信息素更新void UpdateGlobalPathRule(int* bestTour, int globalBestLength);};//计算当前节点到下一节点转移的概率double AntColonySystem::Transition(int i, int j){if (i != j){return (pow(info[i][j],alpha) * pow(visible[i][j], beta));}else{return 0.0;}}//局部更新规则void AntColonySystem::UpdateLocalPathRule(int i, int j){info[i][j] = (1.0 - alpha1) * info[i][j] + alpha1 * (1.0 / (N * Lnn));info[j][i] = info[i][j];}//初始化void AntColonySystem::InitParameter(double value){//初始化路径上的信息素强度tao0for(int i = 0; i < N; i++){for(int j = 0; j < N; j++){info[i][j] = value;info[j][i] = value;if (i != j){visible[i][j] = 1.0 / allDistance[i][j];visible[j][i] = visible[i][j];}}}}//全局信息素更新void AntColonySystem::UpdateGlobalPathRule(int* bestTour, int globalBestLength) {for(int i = 0; i < N; i++){int row = *(bestTour + 2 * i);int col = *(bestTour + 2* i + 1);info[row][col] = (1.0 - rou) * info[row][col] + rou * (1.0 / globalBestLength);info[col][row] =info[row][col];}}class ACSAnt{private:AntColonySystem* antColony;protected:int startCity, cururentCity;//初始城市编号，当前城市编号int allowed[N];//禁忌表int Tour[N][2];//当前路径int currentTourIndex;//当前路径索引，从0开始，存储蚂蚁经过城市的编号public:ACSAnt(AntColonySystem* acs, int start){antColony = acs;startCity = start;}//开始搜索int* Search();//选择下一节点int Choose();//移动到下一节点void MoveToNextCity(int nextCity);};//开始搜索int* ACSAnt::Search(){cururentCity = startCity;int toCity;currentTourIndex = 0;for(int i = 0; i < N; i++){allowed[i] = 1;}allowed[cururentCity] = 0;int endCity;int count = 0;do{count++;endCity = cururentCity;toCity = Choose();if (toCity >= 0){MoveToNextCity(toCity);antColony->UpdateLocalPathRule(endCity, toCity);cururentCity = toCity;}}while(toCity >= 0);MoveToNextCity(startCity);antColony->UpdateLocalPathRule(endCity, startCity);return *Tour;}//选择下一节点int ACSAnt::Choose(){int nextCity = -1;double q = rand()/(double)RAND_MAX;//如果q <= q0,按先验知识，否则则按概率转移，if (q <= qzero){double probability = -1.0;//转移到下一节点的概率for(int i = 0; i < N; i++){//去掉禁忌表中已走过的节点,从剩下节点中选择最大概率的可行节点if (1 == allowed[i]){double prob = antColony->Transition(cururentCity, i);if (prob > probability){nextCity = i;probability = prob;}}}}else{//按概率转移double p = rand()/(double)RAND_MAX;//生成一个随机数,用来判断落在哪个区间段double sum = 0.0;double probability = 0.0;//概率的区间点，p 落在哪个区间段，则该点是转移的方向//计算概率公式的分母的值for(int i = 0; i < N; i++){if (1 == allowed[i]){sum += antColony->Transition(cururentCity, i);}}for(int j = 0; j < N; j++){if (1 == allowed[j] && sum > 0){probability += antColony->Transition(cururentCity, j)/sum;if (probability >= p || (p > 0.9999 && probability > 0.9999)){nextCity = j;break;}}}}return nextCity;}//移动到下一节点void ACSAnt::MoveToNextCity(int nextCity){allowed[nextCity]=0;Tour[currentTourIndex][0] = cururentCity;Tour[currentTourIndex][1] = nextCity;currentTourIndex++;cururentCity = nextCity;}//------------------------------------------//选择下一个节点，配合下面的函数来计算的长度int ChooseNextNode(int currentNode, int visitedNode[]){int nextNode = -1;double shortDistance = 0.0;for(int i = 0; i < N; i++){//去掉已走过的节点,从剩下节点中选择距离最近的节点if (1 == visitedNode[i]){if (shortDistance == 0.0){shortDistance = allDistance[currentNode][i];nextNode = i;}if(shortDistance < allDistance[currentNode][i]){nextNode = i;}}}return nextNode;}//给一个节点由最近邻距离方法计算长度double CalAdjacentDistance(int node){double sum = 0.0;int visitedNode[N];for(int j = 0; j < N; j++){visitedNode[j] = 1;}visitedNode[node] = 0;int currentNode = node;int nextNode;do{nextNode = ChooseNextNode(currentNode, visitedNode);if (nextNode >= 0){sum += allDistance[currentNode][nextNode];currentNode= nextNode;visitedNode[currentNode] = 0;}}while(nextNode >= 0);sum += allDistance[currentNode][node];return sum;}//---------------------------------结束---------------------------------------------//--------------------------主函数-------------------------------------------------- int main(){time_t timer,timerl;time(&timer);unsigned long seed = timer;seed %= 56000;srand((unsigned int)seed);//由矩阵表示两两城市之间的距离calculateAllDistance();//蚁群系统对象AntColonySystem* acs = new AntColonySystem();ACSAnt* ants[M];//蚂蚁均匀分布在城市上for(int k = 0; k < M; k++){ants[k] = new ACSAnt(acs, (int)(k%N));}calculateAllDistance();//随机选择一个节点计算由最近邻方法得到的一个长度int node = rand() % N;Lnn = CalAdjacentDistance(node);//各条路径上初始化的信息素强度double initInfo = 1 / (N * Lnn);acs->InitParameter(initInfo);//全局最优路径int globalTour[N][2];//全局最优长度double globalBestLength = 0.0;for(int i = 0; i < NcMax; i++){//局部最优路径int localTour[N][2];//局部最优长度double localBestLength = 0.0;//当前路径长度double tourLength;for(int j = 0; j < M; j++){int* tourPath = ants[j]->Search();tourLength = calculateSumOfDistance(tourPath);//局部比较，并记录路径和长度if(tourLength < localBestLength || abs(localBestLength - 0.0) < 0.000001){for(int m = 0; m< N; m++){int row = *(tourPath + 2 * m);int col = *(tourPath + 2* m + 1);localTour[m][0] = row;localTour[m][1] = col;}localBestLength = tourLength;}}//全局比较，并记录路径和长度if(localBestLength < globalBestLength || abs(globalBestLength - 0.0) < 0.000001){for(int m = 0; m< N; m++){globalTour[m][0] = localTour[m][0];globalTour[m][1] = localTour[m][1];}globalBestLength = localBestLength;}acs->UpdateGlobalPathRule(*globalTour, globalBestLength);//输出所有蚂蚁循环一次后的迭代最优路径cout<<"第"<<i + 1<<" 迭代最优路径:"<<localBestLength<<"."<<endl;for(int m = 0; m< N; m++){cout<<localTour[m][0]<<".";}cout<<endl;}//输出全局最优路径cout<<"全局最优路径长度:"<<globalBestLength<<endl;cout<<"全局最优路径:";for(int m = 0; m< N; m++){cout<<globalTour[m][0]<<".";}cout<<endl;time(&timerl);int t = timerl - timer;return 0;}//--------------------------主函数结束--------------------------------------------------本文来自CSDN博客，转载请标明出处：/scucj/archive/2009/07/28/4385650.aspx。