人工蜂群算法

最新推荐文章于 2024-04-10 21:49:09 发布

m_lyxx

最新推荐文章于 2024-04-10 21:49:09 发布

阅读量2.6k

点赞数

分类专栏：人工智能算法

人工智能算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、ABC算法原理

在基本ABC算法中，人工蜂群包含三种个体：雇佣蜂、观察蜂和侦查蜂

每个雇佣蜂对应一个确定的蜜源(解向量)，并在迭代中对蜜源的领域进行搜索。

根据蜜源的丰富程度(适应值的大小)采用轮盘赌的方式雇佣观察蜂采蜜(搜索新蜜源)

如果蜜源多次更新没有改进，则放弃该蜜源，雇佣蜂转为侦查蜂随机搜索新蜜源。

(1) 随机初始化

(2) 新蜜源的更新搜索公式

(3) 观察蜂选择雇佣蜂的概率

（4）侦查蜂的产生

为了防止算法陷入局部最优，当蜜源迭代limit次没有改进时，便放弃该蜜源，并且将该蜜源记录在禁忌表中，同时该蜜源对应的雇佣蜂转变为侦查蜂按式(1)随机产生一个新的位置代替原蜜源。

2、控制参数

(1) 蜜源的个数(与雇佣蜂或观察蜂相等)SN

(2) 算法终止的最大进化数(maximum evaluation number)MEN

(3) Limit

3、基本ABC算法的流程为

(1) 根据式(1)初始化种群解xi，i=1,2，…,SN;

(2) 计算种群中各蜜蜂的适应值

(3) cycle=1

(4) repeat

(5) 雇佣蜂根据(2)产生新的解vi并计算适应值

(6) 雇佣蜂根据贪心策略选择蜜源

(7) 根据(3)式计算选择蜜源xi的概率pi

(8) 观察蜂根据概率pi选择蜜源xi，根据(2)式在该蜜源附近产生新的蜜源vi，并计算新蜜源vi的适应值

(9) 观察蜂根据贪心算法选择蜜源

(10) 决定是否存在需要放弃的蜜源，如果存在，根据(1)式随机产生一个蜜源代替它

(11) 记录最优解

(12) cycle = cycle + 1

(13) until cycle=MCN

4、算法可能的改进方式

(1) 新蜜源的搜索领域(2)式的改进(如：其他拓扑邻域)

(2) 观察蜂选择雇佣蜂的概率(3)式的改进(如：动态的)

5、C++程序

 
   [cpp]  
   view plaincopy
#include<iostream>    
#include<time.h>    
#include<stdlib.h>    
#include<cmath>    
#include<fstream>    
#include<iomanip>    
using namespace std;    
    
const int NP=40;//种群的规模，采蜜蜂+观察蜂    
const int FoodNumber=NP/2;//食物的数量，为采蜜蜂的数量    
const int limit=20;//限度，超过这个限度没有更新采蜜蜂变成侦查蜂    
const int maxCycle=10000;//停止条件    
    
/*****函数的特定参数*****/    
const int D=2;//函数的参数个数    
const double lb=-100;//函数的下界     
const double ub=100;//函数的上界    
    
double result[maxCycle]={0};    
    
/*****种群的定义****/    
struct BeeGroup    
{    
    double code[D];//函数的维数    
    double trueFit;//记录真实的最小值    
    double fitness;    
    double rfitness;//相对适应值比例    
    int trail;//表示实验的次数，用于与limit作比较    
}Bee[FoodNumber];    
    
BeeGroup NectarSource[FoodNumber];//蜜源，注意：一切的修改都是针对蜜源而言的    
BeeGroup EmployedBee[FoodNumber];//采蜜蜂    
BeeGroup OnLooker[FoodNumber];//观察蜂    
BeeGroup BestSource;//记录最好蜜源    
    
/*****函数的声明*****/    
double random(double, double);//产生区间上的随机数    
void initilize();//初始化参数    
double calculationTruefit(BeeGroup);//计算真实的函数值    
double calculationFitness(double);//计算适应值    
void CalculateProbabilities();//计算轮盘赌的概率    
void evalueSource();//评价蜜源    
void sendEmployedBees();    
void sendOnlookerBees();    
void sendScoutBees();    
void MemorizeBestSource();    
    
    
/*******主函数*******/    
int main()    
{    
    ofstream output;    
    output.open("dataABC.txt");    
    
    srand((unsigned)time(NULL));    
    initilize();//初始化    
    MemorizeBestSource();//保存最好的蜜源    
            
    //主要的循环    
    int gen=0;    
    while(gen<maxCycle)    
    {    
        sendEmployedBees();    
                
        CalculateProbabilities();    
                
        sendOnlookerBees();    
                
        MemorizeBestSource();    
                
        sendScoutBees();    
                
        MemorizeBestSource();    
    
        output<<setprecision(30)<<BestSource.trueFit<<endl;    
                
        gen++;    
    }    
        
    output.close();    
    cout<<"运行结束!!"<<endl;    
    return 0;    
}    
    
/*****函数的实现****/    
double random(double start, double end)//随机产生区间内的随机数    
{       
    return start+(end-start)*rand()/(RAND_MAX + 1.0);    
}    
    
void initilize()//初始化参数    
{    
    int i,j;    
    for (i=0;i<FoodNumber;i++)    
    {    
        for (j=0;j<D;j++)    
        {    
            NectarSource[i].code[j]=random(lb,ub);    
            EmployedBee[i].code[j]=NectarSource[i].code[j];    
            OnLooker[i].code[j]=NectarSource[i].code[j];    
            BestSource.code[j]=NectarSource[0].code[j];    
        }    
        /****蜜源的初始化*****/    
        NectarSource[i].trueFit=calculationTruefit(NectarSource[i]);    
        NectarSource[i].fitness=calculationFitness(NectarSource[i].trueFit);    
        NectarSource[i].rfitness=0;    
        NectarSource[i].trail=0;    
        /****采蜜蜂的初始化*****/    
        EmployedBee[i].trueFit=NectarSource[i].trueFit;    
        EmployedBee[i].fitness=NectarSource[i].fitness;    
        EmployedBee[i].rfitness=NectarSource[i].rfitness;    
        EmployedBee[i].trail=NectarSource[i].trail;    
        /****观察蜂的初始化****/    
        OnLooker[i].trueFit=NectarSource[i].trueFit;    
        OnLooker[i].fitness=NectarSource[i].fitness;    
        OnLooker[i].rfitness=NectarSource[i].rfitness;    
        OnLooker[i].trail=NectarSource[i].trail;    
    }    
    /*****最优蜜源的初始化*****/    
    BestSource.trueFit=NectarSource[0].trueFit;    
    BestSource.fitness=NectarSource[0].fitness;    
    BestSource.rfitness=NectarSource[0].rfitness;    
    BestSource.trail=NectarSource[0].trail;    
}    
    
double calculationTruefit(BeeGroup bee)//计算真实的函数值    
{    
    double truefit=0;    
    /******测试函数1******/    
    truefit=0.5+(sin(sqrt(bee.code[0]*bee.code[0]+bee.code[1]*bee.code[1]))*sin(sqrt(bee.code[0]*bee.code[0]+bee.code[1]*bee.code[1]))-0.5)    
        /((1+0.001*(bee.code[0]*bee.code[0]+bee.code[1]*bee.code[1]))*(1+0.001*(bee.code[0]*bee.code[0]+bee.code[1]*bee.code[1])));    
    
    return truefit;    
}    
    
double calculationFitness(double truefit)//计算适应值    
{    
    double fitnessResult=0;    
    if (truefit>=0)    
    {    
        fitnessResult=1/(truefit+1);    
    }else    
    {    
        fitnessResult=1+abs(truefit);    
    }    
    return fitnessResult;    
}    
    
void sendEmployedBees()//修改采蜜蜂的函数    
{    
    int i,j,k;    
    int param2change;//需要改变的维数    
    double Rij;//[-1,1]之间的随机数    
    for (i=0;i<FoodNumber;i++)    
    {    
            
        param2change=(int)random(0,D);//随机选取需要改变的维数    
    
        /******选取不等于i的k********/    
        while (1)    
        {    
            k=(int)random(0,FoodNumber);    
            if (k!=i)    
            {    
                break;    
            }    
        }    
    
        for (j=0;j<D;j++)    
        {    
            EmployedBee[i].code[j]=NectarSource[i].code[j];    
        }    
    
        /*******采蜜蜂去更新信息*******/    
        Rij=random(-1,1);    
        EmployedBee[i].code[param2change]=NectarSource[i].code[param2change]+Rij*(NectarSource[i].code[param2change]-NectarSource[k].code[param2change]);    
        /*******判断是否越界********/    
        if (EmployedBee[i].code[param2change]>ub)    
        {    
            EmployedBee[i].code[param2change]=ub;    
        }    
        if (EmployedBee[i].code[param2change]<lb)    
        {    
            EmployedBee[i].code[param2change]=lb;    
        }    
        EmployedBee[i].trueFit=calculationTruefit(EmployedBee[i]);    
        EmployedBee[i].fitness=calculationFitness(EmployedBee[i].trueFit);    
    
        /******贪婪选择策略*******/    
        if (EmployedBee[i].trueFit<NectarSource[i].trueFit)    
        {    
            for (j=0;j<D;j++)    
            {    
                NectarSource[i].code[j]=EmployedBee[i].code[j];    
            }    
            NectarSource[i].trail=0;    
            NectarSource[i].trueFit=EmployedBee[i].trueFit;    
            NectarSource[i].fitness=EmployedBee[i].fitness;    
        }else    
        {    
            NectarSource[i].trail++;    
        }    
    }    
}    
    
void CalculateProbabilities()//计算轮盘赌的选择概率    
{    
    int i;    
    double maxfit;    
    maxfit=NectarSource[0].fitness;    
    for (i=1;i<FoodNumber;i++)    
    {    
        if (NectarSource[i].fitness>maxfit)    
            maxfit=NectarSource[i].fitness;    
    }    
        
    for (i=0;i<FoodNumber;i++)    
    {    
        NectarSource[i].rfitness=(0.9*(NectarSource[i].fitness/maxfit))+0.1;    
    }    
}    
    
void sendOnlookerBees()//采蜜蜂与观察蜂交流信息，观察蜂更改信息    
{    
    int i,j,t,k;    
    double R_choosed;//被选中的概率    
    int param2change;//需要被改变的维数    
    double Rij;//[-1,1]之间的随机数    
    i=0;    
    t=0;    
    while(t<FoodNumber)    
    {    
            
        R_choosed=random(0,1);    
        if(R_choosed<NectarSource[i].rfitness)//根据被选择的概率选择    
        {            
            t++;    
            param2change=(int)random(0,D);    
                
            /******选取不等于i的k********/    
            while (1)    
            {    
                k=(int)random(0,FoodNumber);    
                if (k!=i)    
                {    
                    break;    
                }    
            }    
    
            for(j=0;j<D;j++)    
            {    
                OnLooker[i].code[j]=NectarSource[i].code[j];    
            }    
                
            /****更新******/    
            Rij=random(-1,1);    
            OnLooker[i].code[param2change]=NectarSource[i].code[param2change]+Rij*(NectarSource[i].code[param2change]-NectarSource[k].code[param2change]);    
                
            /*******判断是否越界*******/    
            if (OnLooker[i].code[param2change]<lb)    
            {    
                OnLooker[i].code[param2change]=lb;    
            }    
            if (OnLooker[i].code[param2change]>ub)    
            {       
                OnLooker[i].code[param2change]=ub;    
            }    
            OnLooker[i].trueFit=calculationTruefit(OnLooker[i]);    
            OnLooker[i].fitness=calculationFitness(OnLooker[i].trueFit);    
                
            /****贪婪选择策略******/    
            if (OnLooker[i].trueFit<NectarSource[i].trueFit)    
            {    
                for (j=0;j<D;j++)    
                {    
                    NectarSource[i].code[j]=OnLooker[i].code[j];    
                }    
                NectarSource[i].trail=0;    
                NectarSource[i].trueFit=OnLooker[i].trueFit;    
                NectarSource[i].fitness=OnLooker[i].fitness;    
            }else    
            {    
                NectarSource[i].trail++;    
            }    
        }     
        i++;    
        if (i==FoodNumber)    
        {    
            i=0;    
        }    
    }    
}    
    
    
/*******只有一只侦查蜂**********/    
void sendScoutBees()//判断是否有侦查蜂的出现，有则重新生成蜜源    
{    
    int maxtrialindex,i,j;    
    double R;//[0,1]之间的随机数    
    maxtrialindex=0;    
    for (i=1;i<FoodNumber;i++)    
    {    
        if (NectarSource[i].trail>NectarSource[maxtrialindex].trail)    
        {    
            maxtrialindex=i;    
        }    
    }    
    if(NectarSource[maxtrialindex].trail>=limit)    
    {    
        /*******重新初始化*********/    
        for (j=0;j<D;j++)    
        {    
            R=random(0,1);    
            NectarSource[maxtrialindex].code[j]=lb+R*(ub-lb);    
        }    
        NectarSource[maxtrialindex].trail=0;    
        NectarSource[maxtrialindex].trueFit=calculationTruefit(NectarSource[maxtrialindex]);    
        NectarSource[maxtrialindex].fitness=calculationFitness(NectarSource[maxtrialindex].trueFit);    
    }    
}    
    
void MemorizeBestSource()//保存最优的蜜源    
{    
    int i,j;    
    for (i=1;i<FoodNumber;i++)    
    {    
        if (NectarSource[i].trueFit<BestSource.trueFit)    
        {    
            for (j=0;j<D;j++)    
            {    
                BestSource.code[j]=NectarSource[i].code[j];    
            }    
            BestSource.trueFit=NectarSource[i].trueFit;    
        }    
    }    
}  

收敛曲线

6、JAVA程序

 
   [java]  
   view plaincopy
import java.lang.Math;  
  
public  class beeColony {  
  
/* Control Parameters of ABC algorithm*/  
    int NP=20; /* The number of colony size (employed bees+onlooker bees)*/  
    int FoodNumber = NP/2; /*The number of food sources equals the half of the colony size*/  
    int limit = 100;  /*A food source which could not be improved through "limit" trials is abandoned by its employed bee*/  
    int maxCycle = 2500; /*The number of cycles for foraging {a stopping criteria}*/  
  
    /* Problem specific variables*/  
    int D = 100; /*The number of parameters of the problem to be optimized*/  
    double lb = -5.12; /*lower bound of the parameters. */  
    double ub = 5.12; /*upper bound of the parameters. lb and ub can be defined as arrays for the problems of which parameters have different bounds*/  
  
int runtime = 30;  /*Algorithm can be run many times in order to see its robustness*/  
  
    int dizi1[]=new int[10];  
    double Foods[][]=new double[FoodNumber][D];        /*Foods is the population of food sources. Each row of Foods matrix is a vector holding D parameters to be optimized. The number of rows of Foods matrix equals to the FoodNumber*/  
    double f[]=new double[FoodNumber];        /*f is a vector holding objective function values associated with food sources */  
    double fitness[]=new double[FoodNumber];      /*fitness is a vector holding fitness (quality) values associated with food sources*/  
    double trial[]=new double[FoodNumber];         /*trial is a vector holding trial numbers through which solutions can not be improved*/  
    double prob[]=new double[FoodNumber];          /*prob is a vector holding probabilities of food sources (solutions) to be chosen*/  
    double solution[]=new double[D];            /*New solution (neighbour) produced by v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) j is a randomly chosen parameter and k is a randomlu chosen solution different from i*/  
  
double ObjValSol;              /*Objective function value of new solution*/  
    double FitnessSol;              /*Fitness value of new solution*/  
    int neighbour, param2change;                   /*param2change corrresponds to j, neighbour corresponds to k in equation v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij})*/  
  
    double GlobalMin;                       /*Optimum solution obtained by ABC algorithm*/  
    double GlobalParams[]=new double[D];                   /*Parameters of the optimum solution*/  
    double GlobalMins[]=new double[runtime];              
             /*GlobalMins holds the GlobalMin of each run in multiple runs*/  
    double r; /*a random number in the range [0,1)*/  
  
    /*a function pointer returning double and taking a D-dimensional array as argument */  
    /*If your function takes additional arguments then change function pointer definition and lines calling "...=function(solution);" in the code*/  
  
//  typedef double (*FunctionCallback)(double sol[D]);    
  
    /*benchmark functions */  
  
//  double sphere(double sol[D]);  
//  double Rosenbrock(double sol[D]);  
//  double Griewank(double sol[D]);  
//  double Rastrigin(double sol[D]);  
  
    /*Write your own objective function name instead of sphere*/  
//  FunctionCallback function = &sphere;  
  
    /*Fitness function*/  
    double CalculateFitness(double fun)   
     {  
         double result=0;  
         if(fun>=0)  
         {  
             result=1/(fun+1);  
         }  
         else  
         {  
               
             result=1+Math.abs(fun);  
         }  
         return result;  
     }  
  
    /*The best food source is memorized*/  
    void MemorizeBestSource()   
    {  
       int i,j;  
          
        for(i=0;i<FoodNumber;i++)  
        {  
        if (f[i]<GlobalMin)  
            {  
            GlobalMin=f[i];  
            for(j=0;j<D;j++)  
               GlobalParams[j]=Foods[i][j];  
            }  
        }  
     }  
  
    /*Variables are initialized in the range [lb,ub]. If each parameter has different range, use arrays lb[j], ub[j] instead of lb and ub */  
    /* Counters of food sources are also initialized in this function*/  
  
void init(int index)  
    {  
       int j;  
       for (j=0;j<D;j++)  
            {  
            r = (   (double)Math.random()*32767 / ((double)32767+(double)(1)) );  
            Foods[index][j]=r*(ub-lb)+lb;  
            solution[j]=Foods[index][j];  
            }  
        f[index]=calculateFunction(solution);  
        fitness[index]=CalculateFitness(f[index]);  
        trial[index]=0;  
    }  
  
/*All food sources are initialized */  
    void initial()  
    {  
        int i;  
        for(i=0;i<FoodNumber;i++)  
        {  
        init(i);  
        }  
        GlobalMin=f[0];  
        for(i=0;i<D;i++)  
        GlobalParams[i]=Foods[0][i];  
  
}  
  
    void SendEmployedBees()  
    {  
      int i,j;  
      /*Employed Bee Phase*/  
       for (i=0;i<FoodNumber;i++)  
            {  
            /*The parameter to be changed is determined randomly*/  
            r = ((double) Math.random()*32767 / ((double)(32767)+(double)(1)) );  
            param2change=(int)(r*D);  
              
            /*A randomly chosen solution is used in producing a mutant solution of the solution i*/  
            r = (   (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );  
            neighbour=(int)(r*FoodNumber);  
  
            /*Randomly selected solution must be different from the solution i*/          
           // while(neighbour==i)  
           // {  
           // r = (   (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );  
           // neighbour=(int)(r*FoodNumber);  
           // }  
            for(j=0;j<D;j++)  
            solution[j]=Foods[i][j];  
  
            /*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */  
            r = (   (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );  
            solution[param2change]=Foods[i][param2change]+(Foods[i][param2change]-Foods[neighbour][param2change])*(r-0.5)*2;  
  
            /*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/  
            if (solution[param2change]<lb)  
               solution[param2change]=lb;  
            if (solution[param2change]>ub)  
               solution[param2change]=ub;  
            ObjValSol=calculateFunction(solution);  
            FitnessSol=CalculateFitness(ObjValSol);  
              
            /*a greedy selection is applied between the current solution i and its mutant*/  
            if (FitnessSol>fitness[i])  
            {  
              
            /*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/  
            trial[i]=0;  
            for(j=0;j<D;j++)  
            Foods[i][j]=solution[j];  
            f[i]=ObjValSol;  
            fitness[i]=FitnessSol;  
            }  
            else  
            {   /*if the solution i can not be improved, increase its trial counter*/  
                trial[i]=trial[i]+1;  
            }  
  
}  
  
            /*end of employed bee phase*/  
  
    }  
  
    /* A food source is chosen with the probability which is proportioal to its quality*/  
    /*Different schemes can be used to calculate the probability values*/  
    /*For example prob(i)=fitness(i)/sum(fitness)*/  
    /*or in a way used in the metot below prob(i)=a*fitness(i)/max(fitness)+b*/  
    /*probability values are calculated by using fitness values and normalized by dividing maximum fitness value*/  
    void CalculateProbabilities()  
    {  
         int i;  
         double maxfit;  
         maxfit=fitness[0];  
      for (i=1;i<FoodNumber;i++)  
            {  
               if (fitness[i]>maxfit)  
               maxfit=fitness[i];  
            }  
  
     for (i=0;i<FoodNumber;i++)  
            {  
             prob[i]=(0.9*(fitness[i]/maxfit))+0.1;  
            }  
  
    }  
  
    void SendOnlookerBees()  
    {  
  
      int i,j,t;  
      i=0;  
      t=0;  
      /*onlooker Bee Phase*/  
      while(t<FoodNumber)  
            {  
  
            r = (   (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );  
            if(r<prob[i]) /*choose a food source depending on its probability to be chosen*/  
            {          
            t++;  
              
            /*The parameter to be changed is determined randomly*/  
            r = ((double)Math.random()*32767 / ((double)(32767)+(double)(1)) );  
            param2change=(int)(r*D);  
              
            /*A randomly chosen solution is used in producing a mutant solution of the solution i*/  
            r = (   (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );  
            neighbour=(int)(r*FoodNumber);  
  
            /*Randomly selected solution must be different from the solution i*/          
            while(neighbour == i)  
            {  
                //System.out.println(Math.random()*32767+"  "+32767);  
            r = (   (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );  
            neighbour=(int)(r*FoodNumber);  
            }  
            for(j=0;j<D;j++)  
            solution[j]=Foods[i][j];  
  
            /*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */  
            r = (   (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );  
            solution[param2change]=Foods[i][param2change]+(Foods[i][param2change]-Foods[neighbour][param2change])*(r-0.5)*2;  
  
            /*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/  
            if (solution[param2change]<lb)  
               solution[param2change]=lb;  
            if (solution[param2change]>ub)  
               solution[param2change]=ub;  
            ObjValSol=calculateFunction(solution);  
            FitnessSol=CalculateFitness(ObjValSol);  
              
            /*a greedy selection is applied between the current solution i and its mutant*/  
            if (FitnessSol>fitness[i])  
            {  
            /*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/  
            trial[i]=0;  
            for(j=0;j<D;j++)  
            Foods[i][j]=solution[j];  
            f[i]=ObjValSol;  
            fitness[i]=FitnessSol;  
            }  
            else  
            {   /*if the solution i can not be improved, increase its trial counter*/  
                trial[i]=trial[i]+1;  
            }  
            } /*if */  
            i++;  
            if (i==FoodNumber-1)  
            i=0;  
            }/*while*/  
  
            /*end of onlooker bee phase     */  
    }  
  
    /*determine the food sources whose trial counter exceeds the "limit" value. In Basic ABC, only one scout is allowed to occur in each cycle*/  
    void SendScoutBees()  
    {  
    int maxtrialindex,i;  
    maxtrialindex=0;  
    for (i=1;i<FoodNumber;i++)  
            {  
             if (trial[i]>trial[maxtrialindex])  
             maxtrialindex=i;  
            }  
    if(trial[maxtrialindex]>=limit)  
    {  
        init(maxtrialindex);  
    }  
    }  
  
double calculateFunction(double sol[])  
{  
return Rastrigin (sol);   
}  
    double sphere(double sol[])  
    {  
    int j;  
    double top=0;  
    for(j=0;j<D;j++)  
    {  
    top=top+sol[j]*sol[j];  
    }  
    return top;  
    }  
  
    double Rosenbrock(double sol[])  
    {  
    int j;  
    double top=0;  
    for(j=0;j<D-1;j++)  
    {  
    top=top+100*Math.pow((sol[j+1]-Math.pow((sol[j]),(double)2)),(double)2)+Math.pow((sol[j]-1),(double)2);  
    }  
    return top;  
    }  
  
     double Griewank(double sol[])  
     {  
         int j;  
         double top1,top2,top;  
         top=0;  
         top1=0;  
         top2=1;  
         for(j=0;j<D;j++)  
         {  
             top1=top1+Math.pow((sol[j]),(double)2);  
             top2=top2*Math.cos((((sol[j])/Math.sqrt((double)(j+1)))*Math.PI)/180);  
  
         }    
         top=(1/(double)4000)*top1-top2+1;  
         return top;  
     }  
  
     double Rastrigin(double sol[])  
     {  
         int j;  
         double top=0;  
  
         for(j=0;j<D;j++)  
         {  
             top=top+(Math.pow(sol[j],(double)2)-10*Math.cos(2*Math.PI*sol[j])+10);  
         }  
         return top;  
     }  
}  
  
使用方法是：  
public class test {  
    static beeColony bee=new beeColony();  
      
    public static void main(String[] args) {  
        int iter=0;  
        int run=0;  
        int j=0;  
        double mean=0;  
        //srand(time(NULL));  
        for(run=0;run<bee.runtime;run++)  
        {  
        bee.initial();  
        bee.MemorizeBestSource();  
        for (iter=0;iter<bee.maxCycle;iter++)  
            {  
            bee.SendEmployedBees();  
            bee.CalculateProbabilities();  
            bee.SendOnlookerBees();  
            bee.MemorizeBestSource();  
            bee.SendScoutBees();  
            }  
        for(j=0;j<bee.D;j++)  
        {  
            //System.out.println("GlobalParam[%d]: %f\n",j+1,GlobalParams[j]);  
            System.out.println("GlobalParam["+(j+1)+"]:"+bee.GlobalParams[j]);  
        }  
        //System.out.println("%d. run: %e \n",run+1,GlobalMin);  
        System.out.println((run+1)+".run:"+bee.GlobalMin);  
        bee.GlobalMins[run]=bee.GlobalMin;  
        mean=mean+bee.GlobalMin;  
        }  
        mean=mean/bee.runtime;  
        //System.out.println("Means of %d runs: %e\n",runtime,mean);  
        System.out.println("Means  of "+bee.runtime+"runs: "+mean);  
          
    }  
  
}  

m_lyxx

关注

0
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
人工蜂群算法

1、ABC算法原理在基本ABC算法中，人工蜂群包含三种个体：雇佣蜂、观察蜂和侦查蜂每个雇佣蜂对应一个确定的蜜源(解向量)，并在迭代中对蜜源的领域进行搜索。根据蜜源的丰富程度(适应值的大小)采用轮盘赌的方式雇佣观察蜂采蜜(搜索新蜜源)如果蜜源多次更新没有改进，则放弃该蜜源，雇佣蜂转为侦查蜂随机搜索新蜜源。 (1) 随机初始化 (2) 新蜜源的更新搜索公式 (3) 观察蜂选择雇佣蜂的...
复制链接

扫一扫