一、混沌进化优化算法

https://github.com/ITyuanshou/MATLABCode

1. 算法简介

混沌进化优化算法（Chaotic Evolution Optimization, CEO）是2025年提出的一种受混沌动力学启发的新型元启发式算法。该算法的主要灵感来源于二维离散忆阻映射的混沌进化过程，通过利用忆阻映射的超混沌特性，为进化过程引入随机搜索方向,增强了算法的全局搜索能力和收敛速度。CEO算法在2025年3月发表在中科院1区SCI期刊《Chaos, Solitons & Fractals》。

2. 算法原理

2.1 混沌映射

CEO算法采用二维离散忆阻超混沌映射来生成混沌候选个体，具体公式如下：

$$\{\begin{array}{l}{x}_{n+1}=a_1{x}_n(1-x_n)+b_1{y}_n\\ y_{n+1}=a_2{y}_n(1-y_n)+b_2{x}_n\end{array}$$

其中，$a_1,a_2,b_1,b_2$ 是控制参数，通常取值为 $a_1=3.8,a_2=3.8,b_1=0.5,b_2=0.5$。

2.2 变异操作

1. 映射个体到混沌空间：

   • 从当前种群中随机选择两个个体 $x_t$ 和 $y_t$。
   • 将 $x_t$ 和 $y_t$ 映射到 $[-0.5,0.5]$ 和 $[-0.25,0.25]$ 范围内，分别记为 $x^{\prime }$ 和 $y^{\prime }$：
     $$x^{\prime }=\frac{x_t-lb}{ub-lb}-0.5$$
     $$y^{\prime }=\frac{y_t-lb}{ub-lb}-0.25$$
     其中，$lb$ 和 $ub$ 分别是当前种群变量的下界和上界。

2. 生成混沌候选个体：

   • 使用混沌映射生成 $N$ 个混沌候选个体 $x_{\text{chaos}}$ 和 $y_{\text{chaos}}$：
     $$x_{\text{chaos}}(n)=k\cdot e^{-\cos (n\pi )}-1\cdot x_t$$
     $$y_{\text{chaos}}(n)=y_t^{\prime }+x_t$$
     其中，$k$ 是一个常数，通常取值为 $k=1$。

3. 映射回实际位置：

   • 将混沌候选个体映射回实际位置：
     $$x_{{\text{chaos}}^{\prime }}=x_{\text{chaos}}\cdot 0.5\cdot (ub-lb)+lb$$
     $$y_{{\text{chaos}}^{\prime }}=y_{\text{chaos}}\cdot 0.25\cdot 2\cdot (ub-lb)+lb$$

4. 生成进化方向：

   • 计算进化方向 $d_{x_t}^n$ 和 $d_{y_t}^n$：
     $$d_{x_t}^n=x_{{\text{chaos}}^{\prime }}^n-x_t$$
     $$d_{y_t}^n=y_{{\text{chaos}}^{\prime }}^n-y_t$$

5. 变异操作：

   • 使用进化方向更新个体：
     $$x_{t+1}=x_t+a\cdot d_{x_t}^n$$
     $$y_{t+1}=y_t+a\cdot d_{y_t}^n$$
     其中，$a$ 是搜索步长，通常取值为 $a=0.5$。

2.3 交叉操作

1. 生成试验向量：
   • 对于每个维度 $j$，生成一个随机数 $r_j$，如果 $r_j<CR$ 或 $j=j_{\text{rand}}$，则试验向量 $x_{\text{trial}}^n$ 为变异个体 $x_{t+1}^n$，否则为当前个体 $x_t^n$：
     $$x_{\text{trial}}^n=\{\begin{array}{ll}{x}_{t+1}^n,& \text{if }{r}_j<CR\text{ or }j=j_{\text{rand}}\\ x_t^n,& \text{otherwise}\end{array}$$
     其中，$CR$ 是交叉概率，通常取值为 $CR=0.7$，$j_{\text{rand}}$ 是随机选择的一个维度。

2.4 选择操作

1. 选择操作：
   • 计算当前个体 $x_t$ 和试验向量 $x_{\text{trial}}^n$ 的适应度值。
   • 如果 $f(x_{\text{trial}}^n)<f(x_t)$，则用 $x_{\text{trial}}^n$ 替换 $x_t$，否则保持 $x_t$ 不变：
     $$x_{t+1}=\{\begin{array}{ll}{x}_{\text{trial}}^n,& \text{if }f(x_{\text{trial}}^n)<f(x_t)\\ x_t,& \text{otherwise}\end{array}$$

3. 算法特点

1. 混沌特性：利用二维离散忆阻映射的超混沌特性，增强全局搜索能力。
2. 快速收敛：通过在最优解附近进行局部搜索，加快算法的收敛速度。
3. 简单易实现：算法结构简单，参数较少，易于实现和应用。

4.算法描述

输入

• func：目标函数。
• N：混沌采样数量。
• Np：种群大小。
• MaxFES：最大函数评估次数。

输出

• Best：最优变量。
• fBest：最优函数值。

算法步骤

1. 初始化迭代计数器：

   • $t=1$

2. 初始化种群并评估种群：

   • [Population, fit, fBest, Best] = Initialization(func, Np, Dim)
   • $FEvals=Np$

3. 主循环：

   • 当 $FEvals<MaxFES$ 时，执行以下步骤：

     1. 重复：

        • 从种群中选择两个不同的个体 $[x_t,y_t]$
        • 对 $x_t$ 和 $y_t$ 进行区间映射，得到 $[x_t^{\prime },y_t^{\prime }]$，执行公式 (4)。
        • 通过执行公式 (2) 生成 $N$ 个混沌个体 $[x_{\text{chaos}},y_{\text{chaos}}]$
        • 通过执行公式 (5) 得到实际位置 $[x_{\text{chaos}}^{\prime },y_{\text{chaos}}^{\prime }]$
        • 如果 $rand<0.5$，则执行公式 (7) 进行变异操作，得到 $[{\bar{x}}_{t+1}^n,{\bar{y}}_{t+1}^n]$
        • 否则，执行公式 (8) 进行变异操作，得到 $[{\bar{x}}_{t+1}^n,{\bar{y}}_{t+1}^n]$
        • 生成随机数 $C_r=\text{rand}(0,1)$
        • 通过执行公式 (9) 进行交叉操作，得到 $[x_{\text{trial}}^n,y_{\text{trial}}^n]$
        • 通过执行公式 (10) 和 (11) 进行选择操作，得到 $[x_{t+1},y_{t+1}]$
        • 更新种群和适应度值 $[Population,fit]$
        • $FEvals=FEvals+2\cdot N$

     2. 直到：

        • 种群中的所有个体都被选择一次。

     3. 更新迭代计数器：

        • $t=t+1$

4. 结束主循环：

5. 返回结果：

   • 返回最优变量 $Best$ 和最优函数值 $fBest$

5.详细步骤说明

1. 初始化：

   • 初始化种群并评估每个个体的适应度值，确定当前最优解 $Best$ 和最优函数值 $fBest$。

2. 主循环：

   • 在主循环中，通过混沌映射生成混沌个体，并进行变异、交叉和选择操作，逐步更新种群，直到达到最大函数评估次数 $MaxFES$。

3. 变异操作：

   • 根据随机数 $rand$ 的值，选择执行公式 (7) 或公式 (8) 进行变异操作，生成新的变异个体。

4. 交叉操作：

   • 通过公式 (9) 进行交叉操作，生成试验向量。

5. 选择操作：

   • 通过公式 (10) 和 (11) 进行选择操作，更新种群中的个体。

6. 更新种群：

   • 更新种群和适应度值，继续下一次迭代。

6. 参考文献

[1]Yingchao Dong, Shaohua Zhang, Hongli Zhang, Xiaojun Zhou, Jiading Jiang, Chaotic evolution optimization: A novel metaheuristic algorithm inspired by chaotic dynamics, Chaos, Solitons & Fractals, Volume 192, 2025, 116049, https://doi.org/10.1016/j.chaos.2025.116049.
[2]https://github.com/ITyuanshou/MATLABCode/blob/main/MATLABcode

二、核心MATLAB代码

https://github.com/ITyuanshou/MATLABCode

function [Best, fBest, history] = CEO(func, Np, Dim, Varmin, Varmax, N)
rand('state', sum(100*clock));

if mod(Np,2)~=0
    error('Np must be set to an even number greater than 2！')
end

% Search Range
if length(Varmin)== 1
    lu = repmat([Varmin; Varmax], 1, Dim);
else
    lu = [Varmin; Varmax];
end

% Initialize the main population
[Population,fit,fBest,Best] = Initialization(func,lu, Np, Dim);
history(1) = fBest;

% chaotic initial search domain
low_chacos = [-0.5 -0.25]; 
up_chacos = [0.5 0.25];

t = 1; % Initialization iteration number
counter = 0;
while 1
    oldfBest = fBest;
    rand_num = randperm(Np);
    ub = max(Population); % Upper limit of population per iteration
    lb = min(Population); % Lower limit of population per iteration
    
    for i = 1:2:Np
        index = rand_num(i:i+1);
        xy = Population(index,:); % Randomly select two individuals
        
        % Perform interval mapping on xt and yt by executing Eq. (4).
        xy_dot = ((xy -  lb)./(ub - lb)).*(repmat(up_chacos',1,Dim) - repmat(low_chacos',1,Dim)) + repmat(low_chacos',1,Dim);
        
        % N chaotic individuals are obtained by executing Eq. (2)
        [x_chaos,y_chaos] = EDM(xy_dot(1,:),xy_dot(2,:),N);
        
        chaos_total = [x_chaos;y_chaos]; % Merging particles created by chaos
        
        for k = 1 : 2 % Evaluate each chaotic sequence
            xy_chaos = chaos_total((k-1)*N+1 : k*N,:);
            % Executing Eq. (5) yields the actual position of the corresponding optimization problem.
            xy_chaos_dot = (( xy_chaos -  repmat(low_chacos(:,k),1,Dim) )./(repmat(up_chacos(:,k),1,Dim) - repmat(low_chacos(:,k),1,Dim) )).*(ub - lb) + lb; 
            
            if rand < 0.5 % 
                xy_hat = xy(k,:) + rand(N,1).*( xy_chaos_dot - xy(k,:) ); % Mutation Eq. (7)
            else
                xy_hat = Best + rand(N,1).*( xy_chaos_dot - xy(k,:) ); % Mutation Eq. (8)
            end
            
            CR = rand ;
            xy_trial = Binomial_crossover(xy(k,:), xy_hat, CR); % Crossover Eq. (9)
            xy_trial = boundConstraint (xy_trial, lu);
            fit_xy_trial = fitness(func,xy_trial);
            [fBest_xy_trial,index_best] = min(fit_xy_trial);
            xy_trial_star = xy_trial(index_best,:);
            if  fBest_xy_trial < fit(index(k)) % Selection Eq. (10)
                Population(index(k),:) = xy_trial_star;
                fit(index(k)) = fBest_xy_trial;
            end
        end
        
    end
    
    [fBest,index_best] = min(fit);
    Best = Population(index_best,:);
    
    t = t + 1;
    
    %  termination conditions
    if norm(oldfBest-fBest) < 1e-8 % can be changed
        counter = counter + 1;
        if counter > 50 % can be changed
            disp('满足停止条件');
            break;
        end
    else
        counter = 0;
    end
    
    if mod(t,100)==0
        fprintf('iter=%d  ObjVal=%g\n',t,fBest);
    end
    history(t) = fBest;
    
end

end

function [X,Y] = EDM(x0,y0,itermax)
% exponential discrete memristor (E-DM) map
k = 2.66;
x = x0; % trajectory domain [-1,1]
y = y0;% trajectory domain [-0.5,0.5]
xo = x;
yo = y;
% System iteration
for j = 1:itermax
    xn = k*(exp(-cos(pi.*yo))-1).*xo;
    yn = yo + xo;
    % Stored iteration value
    x =[x; xn];
    y =[y; yn];
    % Update the initial value of each iteration
    xo = xn;
    yo = yn;
end
X =x(2:end,:);
Y =y(2:end,:);
end

function u = Binomial_crossover(p, v, CR)
% Binomial crossover
[N,dim] = size(v);
j_rand = floor(rand(N,1) * dim) + 1;
t = rand(N, dim) < CR;
t(N, j_rand) = 1;
u = t .* v + (1 - t) .* p;
end

function fit = fitness(func,x)
% calculate fitness
SE = size(x,1);
fit = zeros(SE,1);
for i = 1:SE
    fit(i) = feval(func,x(i,:));
end
end