├── README.md
└── src
    └── org
        └── gandhim
            └── pso
                ├── PSODriver.java
                ├── PSOConstants.java
                ├── PSOUtility.java
                ├── Location.java
                ├── Velocity.java
                ├── Particle.java
                ├── ProblemSet.java
                └── PSOProcess.java


/README.md:
--------------------------------------------------------------------------------
1 | pso-example-java
2 | ================
3 | 
4 | Particle Swarm Optimization (PSO) Sample Code using Java
5 | 
6 | This project is a complete version of Particle Swarm Optimization with Java sample code described in http://gandhim.wordpress.com/2010/04/04/particle-swarm-optimization-pso-sample-code-using-java.
7 | 


--------------------------------------------------------------------------------
/src/org/gandhim/pso/PSODriver.java:
--------------------------------------------------------------------------------
 1 | package org.gandhim.pso;
 2 | 
 3 | /* author: gandhi - gandhi.mtm [at] gmail [dot] com - Depok, Indonesia */
 4 | 
 5 | // this is a driver class to execute the PSO process
 6 | 
 7 | public class PSODriver {
 8 | 	public static void main(String args[]) {
 9 | 		new PSOProcess().execute();
10 | 	}
11 | }
12 | 


--------------------------------------------------------------------------------
/src/org/gandhim/pso/PSOConstants.java:
--------------------------------------------------------------------------------
 1 | package org.gandhim.pso;
 2 | 
 3 | /* author: gandhi - gandhi.mtm [at] gmail [dot] com - Depok, Indonesia */
 4 | 
 5 | // this is an interface to keep the configuration for the PSO
 6 | // you can modify the value depends on your needs
 7 | 
 8 | public interface PSOConstants {
 9 | 	int SWARM_SIZE = 30;
10 | 	int MAX_ITERATION = 100;
11 | 	int PROBLEM_DIMENSION = 2;
12 | 	double C1 = 2.0;
13 | 	double C2 = 2.0;
14 | 	double W_UPPERBOUND = 1.0;
15 | 	double W_LOWERBOUND = 0.0;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/org/gandhim/pso/PSOUtility.java:
--------------------------------------------------------------------------------
 1 | package org.gandhim.pso;
 2 | 
 3 | /* author: gandhi - gandhi.mtm [at] gmail [dot] com - Depok, Indonesia */
 4 | 
 5 | // just a simple utility class to find a minimum position on a list
 6 | 
 7 | public class PSOUtility {
 8 | 	public static int getMinPos(double[] list) {
 9 | 		int pos = 0;
10 | 		double minValue = list[0];
11 | 		
12 | 		for(int i=0; i<list.length; i++) {
13 | 			if(list[i] < minValue) {
14 | 				pos = i;
15 | 				minValue = list[i];
16 | 			}
17 | 		}
18 | 		
19 | 		return pos;
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/src/org/gandhim/pso/Location.java:
--------------------------------------------------------------------------------
 1 | package org.gandhim.pso;
 2 | 
 3 | /* author: gandhi - gandhi.mtm [at] gmail [dot] com - Depok, Indonesia */
 4 | 
 5 | // bean class to represent location
 6 | 
 7 | public class Location {
 8 | 	// store the Location in an array to accommodate multi-dimensional problem space
 9 | 	private double[] loc;
10 | 
11 | 	public Location(double[] loc) {
12 | 		super();
13 | 		this.loc = loc;
14 | 	}
15 | 
16 | 	public double[] getLoc() {
17 | 		return loc;
18 | 	}
19 | 
20 | 	public void setLoc(double[] loc) {
21 | 		this.loc = loc;
22 | 	}
23 | 	
24 | }
25 | 


--------------------------------------------------------------------------------
/src/org/gandhim/pso/Velocity.java:
--------------------------------------------------------------------------------
 1 | package org.gandhim.pso;
 2 | 
 3 | /* author: gandhi - gandhi.mtm [at] gmail [dot] com - Depok, Indonesia */
 4 | 
 5 | // bean class to represent velocity
 6 | 
 7 | public class Velocity {
 8 | 	// store the Velocity in an array to accommodate multi-dimensional problem space
 9 | 	private double[] vel;
10 | 
11 | 	public Velocity(double[] vel) {
12 | 		super();
13 | 		this.vel = vel;
14 | 	}
15 | 
16 | 	public double[] getPos() {
17 | 		return vel;
18 | 	}
19 | 
20 | 	public void setPos(double[] vel) {
21 | 		this.vel = vel;
22 | 	}
23 | 	
24 | }
25 | 


--------------------------------------------------------------------------------
/src/org/gandhim/pso/Particle.java:
--------------------------------------------------------------------------------
 1 | package org.gandhim.pso;
 2 | 
 3 | public class Particle {
 4 | 	private double fitnessValue;
 5 | 	private Velocity velocity;
 6 | 	private Location location;
 7 | 	
 8 | 	public Particle() {
 9 | 		super();
10 | 	}
11 | 
12 | 	public Particle(double fitnessValue, Velocity velocity, Location location) {
13 | 		super();
14 | 		this.fitnessValue = fitnessValue;
15 | 		this.velocity = velocity;
16 | 		this.location = location;
17 | 	}
18 | 
19 | 	public Velocity getVelocity() {
20 | 		return velocity;
21 | 	}
22 | 
23 | 	public void setVelocity(Velocity velocity) {
24 | 		this.velocity = velocity;
25 | 	}
26 | 
27 | 	public Location getLocation() {
28 | 		return location;
29 | 	}
30 | 
31 | 	public void setLocation(Location location) {
32 | 		this.location = location;
33 | 	}
34 | 
35 | 	public double getFitnessValue() {
36 | 		fitnessValue = ProblemSet.evaluate(location);
37 | 		return fitnessValue;
38 | 	}
39 | }
40 | 


--------------------------------------------------------------------------------
/src/org/gandhim/pso/ProblemSet.java:
--------------------------------------------------------------------------------
 1 | package org.gandhim.pso;
 2 | 
 3 | /* author: gandhi - gandhi.mtm [at] gmail [dot] com - Depok, Indonesia */
 4 | 
 5 | // this is the problem to be solved
 6 | // to find an x and a y that minimize the function below:
 7 | // f(x, y) = (2.8125 - x + x * y^4)^2 + (2.25 - x + x * y^2)^2 + (1.5 - x + x*y)^2
 8 | // where 1 <= x <= 4, and -1 <= y <= 1
 9 | 
10 | // you can modify the function depends on your needs
11 | // if your problem space is greater than 2-dimensional space
12 | // you need to introduce a new variable (other than x and y)
13 | 
14 | public class ProblemSet {
15 | 	public static final double LOC_X_LOW = 1;
16 | 	public static final double LOC_X_HIGH = 4;
17 | 	public static final double LOC_Y_LOW = -1;
18 | 	public static final double LOC_Y_HIGH = 1;
19 | 	public static final double VEL_LOW = -1;
20 | 	public static final double VEL_HIGH = 1;
21 | 	
22 | 	public static final double ERR_TOLERANCE = 1E-20; // the smaller the tolerance, the more accurate the result, 
23 | 	                                                  // but the number of iteration is increased
24 | 	
25 | 	public static double evaluate(Location location) {
26 | 		double result = 0;
27 | 		double x = location.getLoc()[0]; // the "x" part of the location
28 | 		double y = location.getLoc()[1]; // the "y" part of the location
29 | 		
30 | 		result = Math.pow(2.8125 - x + x * Math.pow(y, 4), 2) + 
31 | 				Math.pow(2.25 - x + x * Math.pow(y, 2), 2) + 
32 | 				Math.pow(1.5 - x + x * y, 2);
33 | 		
34 | 		return result;
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/src/org/gandhim/pso/PSOProcess.java:
--------------------------------------------------------------------------------
  1 | package org.gandhim.pso;
  2 | 
  3 | /* author: gandhi - gandhi.mtm [at] gmail [dot] com - Depok, Indonesia */
  4 | 
  5 | // this is the heart of the PSO program
  6 | // the code is for 2-dimensional space problem
  7 | // but you can easily modify it to solve higher dimensional space problem
  8 | 
  9 | import java.util.Random;
 10 | import java.util.Vector;
 11 | 
 12 | public class PSOProcess implements PSOConstants {
 13 | 	private Vector<Particle> swarm = new Vector<Particle>();
 14 | 	private double[] pBest = new double[SWARM_SIZE];
 15 | 	private Vector<Location> pBestLocation = new Vector<Location>();
 16 | 	private double gBest;
 17 | 	private Location gBestLocation;
 18 | 	private double[] fitnessValueList = new double[SWARM_SIZE];
 19 | 	
 20 | 	Random generator = new Random();
 21 | 	
 22 | 	public void execute() {
 23 | 		initializeSwarm();
 24 | 		updateFitnessList();
 25 | 		
 26 | 		for(int i=0; i<SWARM_SIZE; i++) {
 27 | 			pBest[i] = fitnessValueList[i];
 28 | 			pBestLocation.add(swarm.get(i).getLocation());
 29 | 		}
 30 | 		
 31 | 		int t = 0;
 32 | 		double w;
 33 | 		double err = 9999;
 34 | 		
 35 | 		while(t < MAX_ITERATION && err > ProblemSet.ERR_TOLERANCE) {
 36 | 			// step 1 - update pBest
 37 | 			for(int i=0; i<SWARM_SIZE; i++) {
 38 | 				if(fitnessValueList[i] < pBest[i]) {
 39 | 					pBest[i] = fitnessValueList[i];
 40 | 					pBestLocation.set(i, swarm.get(i).getLocation());
 41 | 				}
 42 | 			}
 43 | 				
 44 | 			// step 2 - update gBest
 45 | 			int bestParticleIndex = PSOUtility.getMinPos(fitnessValueList);
 46 | 			if(t == 0 || fitnessValueList[bestParticleIndex] < gBest) {
 47 | 				gBest = fitnessValueList[bestParticleIndex];
 48 | 				gBestLocation = swarm.get(bestParticleIndex).getLocation();
 49 | 			}
 50 | 			
 51 | 			w = W_UPPERBOUND - (((double) t) / MAX_ITERATION) * (W_UPPERBOUND - W_LOWERBOUND);
 52 | 			
 53 | 			for(int i=0; i<SWARM_SIZE; i++) {
 54 | 				double r1 = generator.nextDouble();
 55 | 				double r2 = generator.nextDouble();
 56 | 				
 57 | 				Particle p = swarm.get(i);
 58 | 				
 59 | 				// step 3 - update velocity
 60 | 				double[] newVel = new double[PROBLEM_DIMENSION];
 61 | 				newVel[0] = (w * p.getVelocity().getPos()[0]) + 
 62 | 							(r1 * C1) * (pBestLocation.get(i).getLoc()[0] - p.getLocation().getLoc()[0]) +
 63 | 							(r2 * C2) * (gBestLocation.getLoc()[0] - p.getLocation().getLoc()[0]);
 64 | 				newVel[1] = (w * p.getVelocity().getPos()[1]) + 
 65 | 							(r1 * C1) * (pBestLocation.get(i).getLoc()[1] - p.getLocation().getLoc()[1]) +
 66 | 							(r2 * C2) * (gBestLocation.getLoc()[1] - p.getLocation().getLoc()[1]);
 67 | 				Velocity vel = new Velocity(newVel);
 68 | 				p.setVelocity(vel);
 69 | 				
 70 | 				// step 4 - update location
 71 | 				double[] newLoc = new double[PROBLEM_DIMENSION];
 72 | 				newLoc[0] = p.getLocation().getLoc()[0] + newVel[0];
 73 | 				newLoc[1] = p.getLocation().getLoc()[1] + newVel[1];
 74 | 				Location loc = new Location(newLoc);
 75 | 				p.setLocation(loc);
 76 | 			}
 77 | 			
 78 | 			err = ProblemSet.evaluate(gBestLocation) - 0; // minimizing the functions means it's getting closer to 0
 79 | 			
 80 | 			
 81 | 			System.out.println("ITERATION " + t + ": ");
 82 | 			System.out.println("     Best X: " + gBestLocation.getLoc()[0]);
 83 | 			System.out.println("     Best Y: " + gBestLocation.getLoc()[1]);
 84 | 			System.out.println("     Value: " + ProblemSet.evaluate(gBestLocation));
 85 | 			
 86 | 			t++;
 87 | 			updateFitnessList();
 88 | 		}
 89 | 		
 90 | 		System.out.println("\nSolution found at iteration " + (t - 1) + ", the solutions is:");
 91 | 		System.out.println("     Best X: " + gBestLocation.getLoc()[0]);
 92 | 		System.out.println("     Best Y: " + gBestLocation.getLoc()[1]);
 93 | 	}
 94 | 	
 95 | 	public void initializeSwarm() {
 96 | 		Particle p;
 97 | 		for(int i=0; i<SWARM_SIZE; i++) {
 98 | 			p = new Particle();
 99 | 			
100 | 			// randomize location inside a space defined in Problem Set
101 | 			double[] loc = new double[PROBLEM_DIMENSION];
102 | 			loc[0] = ProblemSet.LOC_X_LOW + generator.nextDouble() * (ProblemSet.LOC_X_HIGH - ProblemSet.LOC_X_LOW);
103 | 			loc[1] = ProblemSet.LOC_Y_LOW + generator.nextDouble() * (ProblemSet.LOC_Y_HIGH - ProblemSet.LOC_Y_LOW);
104 | 			Location location = new Location(loc);
105 | 			
106 | 			// randomize velocity in the range defined in Problem Set
107 | 			double[] vel = new double[PROBLEM_DIMENSION];
108 | 			vel[0] = ProblemSet.VEL_LOW + generator.nextDouble() * (ProblemSet.VEL_HIGH - ProblemSet.VEL_LOW);
109 | 			vel[1] = ProblemSet.VEL_LOW + generator.nextDouble() * (ProblemSet.VEL_HIGH - ProblemSet.VEL_LOW);
110 | 			Velocity velocity = new Velocity(vel);
111 | 			
112 | 			p.setLocation(location);
113 | 			p.setVelocity(velocity);
114 | 			swarm.add(p);
115 | 		}
116 | 	}
117 | 	
118 | 	public void updateFitnessList() {
119 | 		for(int i=0; i<SWARM_SIZE; i++) {
120 | 			fitnessValueList[i] = swarm.get(i).getFitnessValue();
121 | 		}
122 | 	}
123 | }
124 | 


--------------------------------------------------------------------------------