1.编写框架的目的

在优化算法笔记（一）优化算法的介绍中，已经介绍过了优化算法的基本结构。大多数优化算法的结构都是十分相似的。
　　实现单个算法时，我们可能不需要什么框架。但是我们需要算法之间的对比，免不了需要实现多个算法。
　　由于优化算法之间的结构大致相同，所以我们可以将其相同的部分或者模块抽离出来，形成公共的部分，我们只需要关注每一个算法自身独特的部分即可。
　　为了实现公共部分的抽离，我们需要用到面向对象的思想。在matlab中使用类（classdef）来定义一个基础类，其中编写公共代码，在其他类中只需继承基础类并实现自身独有的方法即可。

2．优化算法公共部分

将优化算法进行抽象可以得到三个部分：种群（个体），规则，环境。
　　其中种群即优化算法中个体组成的种群，规则则是各个优化算法中的算子，环境为我们需要求解的适应度环境。优化算法也可以描述成：在种群中求解在一定规则下最适应目标环境的个体。

具体实现时，我们需要实现的是
（1）个体（种群为个体的列表）
（2）规则（优化算法流程）

2.1个体

各算法中个体的差异其实还是挺大的，不过个体的公共属性比较简单只有两个
（1）位置：适应度函数的输入。
（2）值：适应度函数的值。

2.2 规则

规则其实就是算法的主题，算法的执行过程。每个算法的执行过程必然不一样（一样那就是同一个算法了）。但是算法的执行流程还是有很多相同的部分的。

（1）初始化：初始化个体，一般是在解空间内随机初始化。
（2）循环迭代：在最大迭代次数内执行指定步骤
（3）记录：记录每代的最优解，最优值

3．实现

下面是完整的代码，需要自己动手组成框架。
总目录:../optimization algorithm
框架目录:../optimization algorithm/frame
框架文件：

文件内容：
Unit.m

% 个体基类
classdef Unit
    properties
        % 个体的位置
        position
        % 个体的适应度值
        value
    end
    
    methods
        function self = Unit()
        end
    end
    
end

Algorithm_Impl.m

% 优化算法基类
classdef Algorithm_Impl < handle
    properties
        %当前最优位置
        position_best;
        %当前最优适应度
        value_best;
        %历史最优适应度
        value_best_history;
        %历史最优位置
        position_best_history;
        %是否为求最大值,默认为是
        is_cal_max;
        %适应度函数，需要单独传入
        fitfunction;
        % 调用适应度函数次数
        cal_fit_num = 0;
    end
    properties(Access = protected)
        %维度
        dim;
        %种群中个体的数量
        size;
        %最大迭代次数
        iter_max;
        %解空间下界
        range_min_list;
        %解空间上界
        range_max_list;
        %种群列表
        unit_list;
    end
    
    methods
         % 运行，调用入口
        function run(self)
            tic
            self.init()
            self.iteration()
            toc
            disp(['运行时间: ',num2str(toc)]);

        end
    end
    
    methods (Access = protected)
        % 构造函数
        function self = Algorithm_Impl(dim,size,iter_max,range_min_list,range_max_list)
            self.dim =dim;
            self.size = size;
            self.iter_max = iter_max;
            self.range_min_list = range_min_list;
            self.range_max_list = range_max_list;
            %默认为求最大值
            self.is_cal_max = true;
        end
        
        % 初始化
        function init(self)
            self.position_best=zeros(1,self.dim);
            self.value_best_history=[];
            self.position_best_history=[];
            %设置初始最优值，由于是求最大值，所以设置了最大浮点数的负值
            self.value_best = -realmax('double');
        end
        
        % 开始迭代
        function iteration(self)
            for iter = 1:self.iter_max
                self.update(iter)
            end
        end
        
        % 处理一次迭代
        function update(self,iter)
            % 记录最优值
            for i = 1:self.size
                if(self.unit_list(i).value>self.value_best)
                    self.value_best = self.unit_list(i).value;
                    self.position_best = self.unit_list(i).position;
                end
            end
            disp(['第' num2str(iter) '代']);
            if(self.is_cal_max)
                self.value_best_history(end+1) = self.value_best;
                disp(['最优值=' num2str(self.value_best)]);
            else
                self.value_best_history(end+1) = -self.value_best;
                disp(['最优值=' num2str(-self.value_best)]);
            end
            self.position_best_history = [self.position_best_history;self.position_best];
            disp(['最优解=' num2str(self.position_best)]);
        end
        
        function value = cal_fitfunction(self,position)
            if(isempty(self.fitfunction))
                value = 0;
            else
                % 如果适应度函数不为空则返回适应度值
                if(self.is_cal_max)
                    value = self.fitfunction(position);
                else
                    value = -self.fitfunction(position);
                end
            end
            self.cal_fit_num = self.cal_fit_num+1;
        end
        
        % 越界检查,超出边界则停留在边界上
        function s=get_out_bound_value(self,position,min_list,max_list)
          if(~exist('min_list','var'))
              min_list = self.range_min_list;
          end
          if(~exist('max_list','var'))
              max_list = self.range_max_list;
          end
          % Apply the lower bound vector
          position_tmp=position;
          I=position_tmp<min_list;
          position_tmp(I)=min_list(I);

          % Apply the upper bound vector
          J=position_tmp>max_list;
          position_tmp(J)=max_list(J);
          % Update this new move
          s=position_tmp;
        end
        
        % 越界检查,超出边界则在解空间内随机初始化
        function s=get_out_bound_value_rand(self,position,min_list,max_list)
          if(~exist('min_list','var'))
              min_list = self.range_min_list;
          end
          if(~exist('max_list','var'))
              max_list = self.range_max_list;
          end
          position_rand = unifrnd(self.range_min_list,self.range_max_list);
          % Apply the lower bound vector
          position_tmp=position;
          I=position_tmp<min_list;
          position_tmp(I)=position_rand(I);

          % Apply the upper bound vector
          J=position_tmp>max_list;
          position_tmp(J)=position_rand(J);
          % Update this new move
          s=position_tmp;
        end
        
        
    end

    events
    end
end

注意：此代码实现的是求目标函数最大值，求最小值可将适应度函数乘以-1（框架代码已实现）。
注意：此代码实现的是求目标函数最大值，求最小值可将适应度函数乘以-1（框架代码已实现）。
注意：此代码实现的是求目标函数最大值，求最小值可将适应度函数乘以-1（框架代码已实现）。

4.测试（bushi）

这里只是实现了优化算法框架的公共部分，这还不是一个完整的优化算法，我们无法使用它来求解，在下一篇，在框架的基础上实现 粒子群算法。