Basic PSO Algorithm Implementation (Java)

I. Algorithmic flow

STEP1: Initializes a group of particles (50 particles), including the immediate position and velocity;

STEP2: Calculate the fitness of each particle fitness;

STEP3: For each particle, its fitness is compared with the best position (local) Pbest, if it is better, it will be the best position in the current pbest;

STEP4: For each particle, it will adapt its value to the best position of the population gbest to compare, if it is better, it is the best position gbest;

STEP5: Update all particle locations and velocities;

STEP6: Turn STEP2 If the end condition is not reached.

Two. Experiment Setup

(1) Number of particles particle_num=20;

(2) Number of iterations n=50;

(3) inertia factor w=1.4;

(4) c1=c2=2;

(5) Maximum speed vmax=2.

Three. Experiment Notes

PSO Wiki: https://en.wikipedia.org/wiki/Particle_swarm_optimization

Objective function: Ackley ' s function in Https://en.wikipedia.org/wiki/Test_functions_for_optimization, Sphere function, and Rosenbrock function (both are minimum values)

Full code, see my GITHUB:HTTPS://GITHUB.COM/WQPOD2G/PSO.

Four. Java code

1.particle class

 PackageNju.iip;ImportJava.util.Random;/*** Particle class *@authormrpod2g **/ Public classParticle {//Number of dimensions     Public  intDimension = 2; //the position of the particle     Public Double[] X =New Double[Dimension]; //Local Best Location     Public Double[] Pbest =New Double[Dimension]; //Velocity of particles     Public Double[] V =New Double[Dimension]; //Max speed     Public DoubleVmax = 2; //Adaptive Values     Public DoubleFitness; /*** Calculate the adaptive value according to the current position *@returnnewfitness*/     Public Doublecalculatefitness () {//1.Ackley ' s function://Double newfitness = -20*math.pow (MATH.E, ( -0.2*math.sqrt (0.5* (x[0]*x[0]+x[1]*x[1))))-math.pow (MATH.E, (0.5* (            Math.Cos (2*math.pi*x[0]) +math.cos (2*math.pi*x[1]))) +math.e+20; //2.Sphere function//double newfitness = x[0]*x[0]+x[1]*x[1]; //3.Rosenbrock function        Doublenewfitness = 100* (Math.pow ((x[1]-x[0]*x[0)), 2) +math.pow ((x[0]-1), 2); returnnewfitness; }            /*** Initialize your location and pbest*/     Public voidInitialx () { for(inti=0;i<dimension;i++) {X[i]=NewRandom (). Nextint (100); Pbest[i]=X[i]; }    }        /*** Initialize your own speed*/     Public voidInitialv () { for(inti=0;i<dimension;i++) {            DoubleTMP =NewRandom (). nextdouble ();//Randomly generates a random fraction of a 0~1V[i] = tmp*4+ (-2); }    }    }

2.PSO Algorithm Implementation process

 PackageNju.iip;Importjava.util.ArrayList;Importjava.util.List;ImportJava.util.Random;/*** PSO Algorithm Implementation *@authormrpod2g **/ Public classPSO {Private Static Double[] gbest;//Global Optimal location        Private Static Doublegbest_fitness = Double.max_value;//Fitness of the global optimal position        Private Static intParticle_num = 20;//Number of particles        Private Static intN = 50;//Number of iterations        Private Static intC1,C2 = 2; Private Static Doublew = 1.4;//Inertia factor        Private StaticList<particle> particles =NewArraylist<particle> ();//particle swarm        /*** Initialization of all particles*/     Public Static voidInitialparticles () { for(inti=0;i<particle_num;i++) {particle particle=Newparticle ();            Particle.initialx ();            Particle.initialv (); Particle.fitness=particle.calculatefitness ();        Particles.add (particle); }    }        /*** Update Gbest*/     Public Static voidupdategbest () {DoubleFitness =Double.max_value; intindex = 0;  for(inti=0;i<particle_num;i++) {            if(Particles.get (i) .fitness<Fitness) {Index=i; Fitness=Particles.get (i). Fitness; }        }        if(fitness<gbest_fitness) {gbest=particles.get (Index). Pbest.clone (); Gbest_fitness=Fitness; }    }        /*** With the speed of each new particle*/     Public Static voidUpdatev () { for(particle particle:particles) { for(inti=0;i<particle.dimension;i++) {                Doublev = w*particle. V[i]+c1*rand () * (particle.pbest[i]-particle. X[i]) +c2*rand () * (gbest[i]-particle.                X[i]); if(v>particle. Vmax) v=particle.                Vmax; Else if(v<-particle. Vmax) v= -particle.                Vmax; Particle. V[i]= V;//Update VI            }        }    }        /*** Update the position and pbest of each particle*/     Public Static voidUpdatex () { for(particle particle:particles) { for(inti=0;i<particle.dimension;i++) {particle. X[i]= particle. X[i] +particle.            V[i]; }            DoubleNewfitness = Particle.calculatefitness ();//New Adaptive Values//if the new adaptation value is smaller than the original, the new fitness and Pbest            if(newfitness<particle.fitness) {particle.pbest=particle.                X.clone (); Particle.fitness=newfitness; }        }    }        /*** Algorithm main flow*/     Public Static voidprocess () {intn = 0;        Initialparticles ();        Updategbest ();  while(n++<N) {Updatev ();            Updatex ();            Updategbest (); SYSTEM.OUT.PRINTLN (n+ ". Current gbest: (" +gbest[0]+ "," +gbest[1]+ ") fitness=" +gbest_fitness); }    }        /*** Returns a random number of 0~1 *@return     */     Public Static Doublerand () {return NewRandom (). nextdouble (); }         Public Static voidMain (string[] args) {process (); }}

Basic PSO Algorithm Implementation (Java)