pso.js

(function () {
	'use strict';

	function Particle(position, velocity, options) {
		this.position = position;
		this.velocity = velocity;
		this.bestPosition = new Array(this.position.length);
		this.fitness = -Infinity;
		this.bestFitness = -Infinity;

		this._inertiaWeight = options.inertiaWeight;
		this._social = options.social;
		this._personal = options.personal;
	}

	Particle.prototype = {

		storePosition: function () {
			this.bestPosition = this.position.slice(0);
		},

		getPosition: function () {
			return this.position.slice(0);
		},

		getBestPosition: function () {
			return this.bestPosition.slice(0);
		},

		updateVelocity: function (globalBest, random) {
			this.position.forEach(function (component, index) {
				var inertia = this.velocity[index] * this._inertiaWeight;
				var socialInfluence = (globalBest.position[index] - component) * random() * this._social;
				var personalInfluence = (this.bestPosition[index] - component) * random() * this._personal;

				this.velocity[index] = inertia + socialInfluence + personalInfluence;
			}, this);
		},

		updatePosition: function () {
			this.velocity.forEach(function (component, index) {
				this.position[index] += component;
			}, this);
		}
	};

	Particle.createRandom = function (domain, options, random) {
		var position = domain.map(function (interval) {
			return random() * (interval.end - interval.start) + interval.start;
		});

		var velocity = domain.map(function (interval) {
			return (random() * (interval.end - interval.start)) * 0.05;
		});

		return new Particle(position, velocity, options);
	};

	function Interval(start, end) {
		this.start = start;
		this.end = end;
	}

	function Optimizer() {
		this._particles = null;
		this._objectiveFunction = null;

		this._bestPositionEver = null;
		this._bestFitnessEver = -Infinity;

		this._options = {
			inertiaWeight: 0.8,
			social: 0.4,
			personal: 0.4,
			pressure: 0.5
		};

		this._async = false;
		this._waiting = false;

		this.rng = {
			random: Math.random,
			setSeed: function () {}
		};
	}

	Optimizer.prototype = {
		setOptions: function (options) {

			if (options.inertiaWeight !== undefined) {
				this._options.inertiaWeight = options.inertiaWeight;
			}

			if (options.social !== undefined) {
				this._options.social = options.social;
			}

			if (options.personal !== undefined) {
				this._options.personal = options.personal;
			}

			if (options.pressure !== undefined) {
				this._options.pressure = options.pressure;
			}
		},

		setObjectiveFunction: function (objectiveFunction, options) {
			this._objectiveFunction = objectiveFunction;
			this._async = options && options.async;
		},

		init: function (nParticles, generationOption) {
			var generator = generationOption instanceof Function ?
				generationOption :
				function () {
					return Particle.createRandom(generationOption, this._options, this.rng.random);
				}.bind(this);

			this._bestPositionEver = null;
			this._bestFitnessEver = -Infinity;

			this._particles = [];
			for (var i = 0; i < nParticles; i++) {
				this._particles.push(generator());
			}
		},

		_getRandomBest: function (except) {
			var ret = Math.floor(this.rng.random() * this._particles.length);

			this._particles.forEach(function (particle, index) {
				if (
					this.rng.random() < this._options.pressure &&
					this._particles[index].fitness > this._particles[ret].fitness &&
					index !== except
				) {
					ret = index;
				}
			}, this);

			return ret;
		},

		step: function (callback) {
			if (this._async) {
				if (this._waiting) {
					console.warn('Cannot step again before previous requests have been completed!');
					return;
				}
				this._waiting = true;
				var completed = 0;
				this._particles.forEach(function (particle) {
					this._objectiveFunction(particle.position, function (fitness) {
						particle.fitness = fitness;
						completed++;
						if (completed >= this._particles.length) {
							this._waiting = false;
							this._completeStep();
							callback();
						}
					}.bind(this));
				}, this);
			} else {
				this._particles.forEach(function (particle) {
					particle.fitness = this._objectiveFunction(particle.position);
				}, this);
				this._completeStep();
			}
		},

		_completeStep: function () {

			this._particles.forEach(function (particle) {
				if (particle.fitness > particle.bestFitness) {
					particle.bestFitness = particle.fitness;
					particle.storePosition();

					if (particle.fitness > this._bestFitnessEver) {
						this._bestFitnessEver = particle.fitness;
						this._bestPositionEver = particle.getPosition();
					}
				}
			}, this);

			this._particles.forEach(function (particle, index) {
				var randomBest = this._particles[this._getRandomBest(index)];
				particle.updateVelocity(randomBest, this.rng.random);
			}, this);

			this._particles.forEach(function (particle) {
				particle.updatePosition();
			});
		},

		getParticles: function () {
			return this._particles.map(function (particle) {
				return {
					position: particle.getPosition(),
					fitness: particle.fitness,
					bestPosition: particle.getBestPosition(),
					bestFitness: particle.bestFitness
				};
			});
		},

		getBestPosition: function () {
			return this._bestPositionEver;
		},

		getBestFitness: function () {
			return this._bestFitnessEver;
		},

		getMeanFitness: function () {
			var sum = this._particles.reduce(function (partialSum, particle) {
				return partialSum + particle.fitness;
			}, 0);
			return sum / this._particles.length;
		}
	};

	if (typeof define === 'function' && define.amd) {

		define('pso/Interval', function () { return Interval; });
		define('pso/Particle', function () { return Particle; });
		define('pso/Optimizer', function () { return Optimizer; });
	} else {
		var pso = {
			Interval: Interval,
			Particle: Particle,
			Optimizer: Optimizer
		};
		if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {

			self.pso = pso;
		} else if (typeof module !== 'undefined' && module.exports) {

			module.exports = pso;
		} else {

			window.pso = pso;
		}
	}
})();