案例一：求解函数最小值

 

目标函数为f(x)=x^4-2x^2+3，求该函数在区间[-2,2]上的最小值。

 

function [x,fval] = simulated_annealing(fun,x0,options)

    % 设置默认选项

    default_options = struct('T0',100,'alpha',0.95,'T_min',1e-8,'max_iter',1000,'verbose',false);

    if nargin < 3

        options = default_options;

    else

        options = merge_options(default_options,options);

    end

    % 初始化参数

    T = options.T0;

    x = x0;

    fval = feval(fun,x);

    iter = 0;

    best_x = x;

    best_fval = fval;

    % 开始迭代

    while T > options.T_min && iter < options.max_iter

        % 产生新解

        new_x = x + randn*0.5;

        new_x = max(min(new_x,2),-2);

        new_fval = feval(fun,new_x);

        delta_f = new_fval - fval;

        % 接受新解

        if delta_f < 0 || exp(-delta_f/T) > rand()

            x = new_x;

            fval = new_fval;

            if fval < best_fval

                best_x = x;

                best_fval = fval;

            end

        end

        % 降温

        T = options.alpha * T;

        % 更新迭代计数器

        iter = iter + 1;

    end

    x = best_x;

    fval = best_fval;

end

 

function opt = merge_options(default_opt,opt)

    if isempty(opt)

        opt = default_opt;

    else

        fields = fieldnames(default_opt);

        for i = 1:length(fields)

            if ~isfield(opt,fields{i})

                opt.(fields{i}) = default_opt.(fields{i});

            end

        end

    end

end

 

fun = @(x) x^4 - 2*x^2 + 3;

x0 = 1;

options = struct('T0',100,'alpha',0.95,'T_min',1e-8,'max_iter',1000,'verbose',true);

[x,fval] = simulated_annealing(fun,x0,options);

 

 

案例二：旅行商问题（TSP）

 

假设有10个城市，坐标分别为(x,y)，计算出一条最短的旅行路线。

 

% 城市坐标

city_coords = [

    1 2;

    3 4;

    5 6;

    7 8;

    9 10;

    11 12;

    13 14;

    15 16;

    17 18;

    19 20

];

n = size(city_coords, 1);

% 计算距离矩阵

distance_matrix = zeros(n);

for i = 1:n

    for j = 1:n

        distance_matrix(i, j) = norm(city_coords(i, :) - city_coords(j, :));

    end

end

% 模拟退火算法参数

T0 = 100;

alpha = 0.95;

T_min = 1e-8;

max_iter = 1000;

% 初始化路径

current_path = randperm(n);

current_distance = calculate_distance(current_path, distance_matrix);

best_path = current_path;

best_distance = current_distance;

T = T0;

for iter = 1:max_iter

    % 产生新路径

    new_path = generate_new_path(current_path);

    new_distance = calculate_distance(new_path, distance_matrix);

    delta_distance = new_distance - current_distance;

    % 接受新路径

    if delta_distance < 0 || exp(-delta_distance/T) > rand()

        current_path = new_path;

        current_distance = new_distance;

        if current_distance < best_distance

            best_path = current_path;

            best_distance = current_distance;

        end

    end

    % 降温

    T = alpha * T;

end

function distance = calculate_distance(path, distance_matrix)

    n = length(path);

    distance = 0;

    for i = 1:(n - 1)

        distance = distance + distance_matrix(path(i), path(i + 1));

    end

    distance = distance + distance_matrix(path(n), path(1));

end

function new_path = generate_new_path(current_path)

    n = length(current_path);

    i = randi([1, n]);

    j = randi([1, n]);

    while i == j

        j = randi([1, n]);

    end

    new_path = current_path;

    new_path(i) = current_path(j);

    new_path(j) = current_path(i);

end

 

 

上述代码，第一个案例中的函数 simulated_annealing 实现了模拟退火算法，用于求解函数的最小值，案例二中定义了城市坐标和距离矩阵，并实现了计算路径距离的函数 calculate_distance 和产生新路径的函数 generate_new_path ，最终得到最优旅行路线。