Index: /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/MultiPSOTopologyUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/MultiPSOTopologyUpdater.cs	(revision 5591)
+++ /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/MultiPSOTopologyUpdater.cs	(revision 5592)
@@ -31,7 +31,8 @@
 
 namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
-  [Item("Multi PSO Topology Updater", "Splits swarm into swarmsize / (nrOfConnections + 1) non-overlapping sub-swarms. Swarms are re-grouped every regroupingPeriod iteration. The operator is implemented as described in Liang, J.J. and Suganthan, P.N 2005. Dynamic multi-swarm particle swarm optimizer. IEEE Swarm Intelligence Symposium, pp. 124-129.")]
+  [Item("Multi PSO Topology Updater", "Splits swarm into NrOfSwarms non-overlapping sub-swarms. Swarms are re-grouped every regroupingPeriod iteration. The operator is implemented as described in Liang, J.J. and Suganthan, P.N 2005. Dynamic multi-swarm particle swarm optimizer. IEEE Swarm Intelligence Symposium, pp. 124-129.")]
   [StorableClass]
   public sealed class MultiPSOTopologyUpdater : SingleSuccessorOperator, ITopologyUpdater {
+
     public override bool CanChangeName {
       get { return false; }
@@ -42,6 +43,6 @@
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public IValueLookupParameter<IntValue> NrOfConnectionsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["NrOfConnections"]; }
+    public IValueLookupParameter<IntValue> NrOfSwarmsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["NrOfSwarms"]; }
     }
     public ILookupParameter<IntValue> SwarmSizeParameter {
@@ -63,6 +64,6 @@
       get { return RandomParameter.ActualValue; }
     }
-    private int NrOfConnections {
-      get { return NrOfConnectionsParameter.ActualValue.Value; }
+    private int NrOfSwarms {
+      get { return NrOfSwarmsParameter.ActualValue.Value; }
     }
     private int SwarmSize {
@@ -81,12 +82,12 @@
     #endregion
 
+    #region Construction & Cloning
     [StorableConstructor]
     private MultiPSOTopologyUpdater(bool deserializing) : base(deserializing) { }
     private MultiPSOTopologyUpdater(MultiPSOTopologyUpdater original, Cloner cloner) : base(original, cloner) { }
-    
     public MultiPSOTopologyUpdater()
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "A random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("NrOfConnections", "Nr of connected neighbors.", new IntValue(3)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NrOfSwarms", "Nr of connected sub-swarms.", new IntValue(3)));
       Parameters.Add(new LookupParameter<IntValue>("SwarmSize", "Number of particles in the swarm."));
       Parameters.Add(new ScopeTreeLookupParameter<IntArray>("Neighbors", "The list of neighbors for each particle."));
@@ -94,52 +95,40 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("RegroupingPeriod", "Update interval (=iterations) for regrouping of neighborhoods.", new IntValue(5)));
     }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new MultiPSOTopologyUpdater(this, cloner);
     }
+    #endregion
 
-    // Splits the swarm into non-overlapping sub swarms
     public override IOperation Apply() {
       if (CurrentIteration > 0 && CurrentIteration % RegroupingPeriod == 0) {
         ItemArray<IntArray> neighbors = new ItemArray<IntArray>(SwarmSize);
-        Dictionary<int, List<int>> neighborsPerParticle = new Dictionary<int, List<int>>();
-        for (int i = 0; i < SwarmSize; i++) {
-          neighborsPerParticle.Add(i, new List<int>());
+
+        var particles = Enumerable.Range(0, SwarmSize).ToList();
+        for (int i = SwarmSize-1; i>0; i--) {
+          int j = Random.Next(i+1);
+          int t = particles[j];
+          particles[j] = particles[i];
+          particles[i] = t;
         }
 
-        // partition swarm into groups
-        Dictionary<int, List<int>> groups = new Dictionary<int, List<int>>();
-        int groupId = 0;
-        var numbers = Enumerable.Range(0, SwarmSize).ToList();
-        for (int i = 0; i < SwarmSize; i++) {
-          int nextParticle = numbers[Random.Next(0, numbers.Count)];
-          if (!groups.ContainsKey(groupId)) {
-            groups.Add(groupId, new List<int>());
-          }
-          groups[groupId].Add(nextParticle);
-          if (groups[groupId].Count - 1 == NrOfConnections) {
-            groupId++;
-          }
-          numbers.Remove(nextParticle);
+        for (int partitionNr = 0; partitionNr<NrOfSwarms; partitionNr++) {
+          int start = partitionNr*SwarmSize/NrOfSwarms;
+          int end = (partitionNr+1)*SwarmSize/NrOfSwarms;
+          for (int i = start; i<end; i++)
+            neighbors[particles[i]] = GetSegment(particles, start, end, i);
         }
 
-        // add neighbors to each particle
-        foreach (List<int> group in groups.Values) {
-          foreach (int sib1 in group) {
-            foreach (int sib2 in group) {
-              if (sib1 != sib2 && !neighborsPerParticle[sib1].Contains(sib2)) {
-                neighborsPerParticle[sib1].Add(sib2);
-              }
-            }
-          }
-        }
-
-        for (int particle = 0; particle < neighborsPerParticle.Count; particle++) {
-          neighbors[particle] = new IntArray(neighborsPerParticle[particle].ToArray());
-        }
         Neighbors = neighbors;
       }
       return base.Apply();
     }
+
+    public static IntArray GetSegment(IEnumerable<int> list, int start, int end, int excludedIndex) {
+      return new IntArray(list
+        .Skip(start)
+        .Take(end-start)
+        .Where((p, j) => start+j != excludedIndex)
+        .ToArray());
+    }
   }
 }
Index: /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimizationMainLoop.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimizationMainLoop.cs	(revision 5591)
+++ /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimizationMainLoop.cs	(revision 5592)
@@ -33,4 +33,5 @@
   [StorableClass]
   public class ParticleSwarmOptimizationMainLoop : AlgorithmOperator {
+
     #region Parameter Properties
     public IValueLookupParameter<IRandom> RandomParameter {
@@ -96,6 +97,6 @@
       #region Create parameters
       Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("SwarmSize", "Size of the particle swarm.", new IntValue(10)));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MaxIterations", "Maximal number of iterations.", new IntValue(1000)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SwarmSize", "Size of the particle swarm."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaxIterations", "Maximal number of iterations."));
 
       Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorNeighborhoodParticleUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorNeighborhoodParticleUpdater.cs	(revision 5591)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorNeighborhoodParticleUpdater.cs	(revision 5592)
@@ -30,27 +30,31 @@
   public sealed class RealVectorNeighborhoodParticleUpdater : RealVectorParticleUpdater, ILocalParticleUpdater {
 
+    #region Construction & Cloning
     [StorableConstructor]
     private RealVectorNeighborhoodParticleUpdater(bool deserializing) : base(deserializing) { }
     private RealVectorNeighborhoodParticleUpdater(RealVectorNeighborhoodParticleUpdater original, Cloner cloner) : base(original, cloner) { }
     public RealVectorNeighborhoodParticleUpdater() : base() { }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new RealVectorNeighborhoodParticleUpdater(this, cloner);
     }
+    #endregion
 
     public override IOperation Apply() {
+      double inertia = Inertia.Value;
+      double personalBestAttraction = PersonalBestAttraction.Value;
+      double neighborBestAttraction = NeighborBestAttraction.Value;
+
       RealVector velocity = new RealVector(Velocity.Length);
       RealVector position = new RealVector(RealVector.Length);
       double r_p = Random.NextDouble();
       double r_g = Random.NextDouble();
-      double omega = Inertia.Value;
-      double phi_p = PersonalBestAttraction.Value;
-      double phi_g = NeighborBestAttraction.Value;
+
       for (int i = 0; i < velocity.Length; i++) {
         velocity[i] =
-          Velocity[i] * omega +
-          (PersonalBest[i] - RealVector[i]) * phi_p * r_p +
-          (BestPoint[i] - RealVector[i]) * phi_g * r_g;
+          Velocity[i] * inertia +
+          (PersonalBest[i] - RealVector[i]) * personalBestAttraction * r_p +
+          (BestPoint[i] - RealVector[i]) * neighborBestAttraction * r_g;
       }
+
       BoundsChecker.Apply(velocity, VelocityBounds);
       for (int i = 0; i < velocity.Length; i++) {
@@ -58,4 +62,5 @@
       }
       BoundsChecker.Apply(position, Bounds);
+
       RealVector = position;
       Velocity = velocity;
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleCreator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleCreator.cs	(revision 5591)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleCreator.cs	(revision 5592)
@@ -20,81 +20,80 @@
 #endregion
 
-using System; 
-using HeuristicLab.Operators;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   [Item("RealVectorParticleCreator", "Creates a particle with position, zero velocity vector and personal best.")]
   [StorableClass]
-  public class RealVectorParticleCreator : SingleSuccessorOperator, IRealVectorParticleCreator {
-    #region IRealVectorParticleCreator Members
+  public class RealVectorParticleCreator : AlgorithmOperator, IRealVectorParticleCreator {
+
+    #region Parameters
     public ILookupParameter<IntValue> ProblemSizeParameter {
-     get { return (ILookupParameter<IntValue>)Parameters["ProblemSize"]; }
+      get { return (ILookupParameter<IntValue>)Parameters["ProblemSize"]; }
     }
-
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
     public ILookupParameter<RealVector> RealVectorParameter {
       get { return (ILookupParameter<RealVector>)Parameters["RealVector"]; }
     }
-
     public ILookupParameter<RealVector> PersonalBestParameter {
       get { return (ILookupParameter<RealVector>)Parameters["PersonalBest"]; }
     }
-
-    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
-      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
-    }
-
     public ILookupParameter<RealVector> VelocityParameter {
       get { return (ILookupParameter<RealVector>)Parameters["Velocity"]; }
     }
-
     #endregion
 
-    public RealVectorParticleCreator() : base() {
+    #region Parameter Values
+    protected int ProblemSize {
+      get { return ProblemSizeParameter.ActualValue.Value; }
+    }
+    protected RealVector Velocity {
+      set { VelocityParameter.ActualValue = value; }
+    }
+    #endregion
+
+    #region Construction & Cloning
+    [StorableConstructor]
+    protected RealVectorParticleCreator(bool deserializing) : base(deserializing) { }
+    protected RealVectorParticleCreator(RealVectorParticleCreator original, Cloner cloner) : base(original, cloner) { }
+    public RealVectorParticleCreator()
+      : base() {
       Parameters.Add(new LookupParameter<IntValue>("ProblemSize", "The dimension of the problem."));
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds in each dimension."));
       Parameters.Add(new LookupParameter<RealVector>("RealVector", "Particle's current solution"));
       Parameters.Add(new LookupParameter<RealVector>("PersonalBest", "Particle's personal best solution."));
-      Parameters.Add(new LookupParameter<RealVector>("Velocity", "Particle's current velocity."));   
-    }
+      Parameters.Add(new LookupParameter<RealVector>("Velocity", "Particle's current velocity."));
 
-    public override IOperation Apply() {
-      VelocityParameter.ActualValue = new RealVector(ProblemSizeParameter.ActualValue.Value);
-      UniformRandomRealVectorCreator realVectorCreater = new UniformRandomRealVectorCreator(); 
+      UniformRandomRealVectorCreator realVectorCreater = new UniformRandomRealVectorCreator();
       Assigner personalBestPositionAssigner = new Assigner();
 
-      this.Name = "Particle Creator";
+      OperatorGraph.InitialOperator = realVectorCreater;
 
-      //realVectorCreater.Name = "(SolutionCreator)";
-      realVectorCreater.RealVectorParameter.ActualName = "RealVector";
+      realVectorCreater.RealVectorParameter.ActualName = RealVectorParameter.Name;
       realVectorCreater.LengthParameter.ActualName = ProblemSizeParameter.Name;
-      realVectorCreater.BoundsParameter.ActualName = BoundsParameter.Name; 
+      realVectorCreater.BoundsParameter.ActualName = BoundsParameter.Name;
       realVectorCreater.Successor = personalBestPositionAssigner;
 
-      personalBestPositionAssigner.LeftSideParameter.ActualName = "PersonalBest";
-      personalBestPositionAssigner.RightSideParameter.ActualName = "RealVector";
-      personalBestPositionAssigner.Successor = null; 
-
-      OperationCollection next = new OperationCollection();
-      next.Add(ExecutionContext.CreateChildOperation(realVectorCreater));
-      next.Add(base.Apply());
-      return next;
+      personalBestPositionAssigner.LeftSideParameter.ActualName = PersonalBestParameter.Name;
+      personalBestPositionAssigner.RightSideParameter.ActualName = RealVectorParameter.Name;
+      personalBestPositionAssigner.Successor = null;
     }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new RealVectorParticleCreator(this, cloner);
     }
+    #endregion
 
-    protected RealVectorParticleCreator(RealVectorParticleCreator original, Cloner cloner)
-      : base(original, cloner) {
+    public override IOperation Apply() {
+      Velocity = new RealVector(ProblemSize);
+      return base.Apply();
     }
 
-    [StorableConstructor]
-    protected RealVectorParticleCreator(bool deserializing) : base(deserializing) { }
+
   }
 }
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs	(revision 5591)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs	(revision 5592)
@@ -28,7 +28,9 @@
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
+
   [Item("RealVectorParticleUpdater", "Updates a certain particle taking the current position and velocity into account, as well as the best point and the best point in a local neighborhood.")]
   [StorableClass]
   public abstract class RealVectorParticleUpdater : SingleSuccessorOperator, IRealVectorParticleUpdater {
+
     public override bool CanChangeName {
       get { return false; }
@@ -110,9 +112,7 @@
 
     #region Construction & Cloning
-
     [StorableConstructor]
     protected RealVectorParticleUpdater(bool deserializing) : base(deserializing) { }
     protected RealVectorParticleUpdater(RealVectorParticleUpdater original, Cloner cloner) : base(original, cloner) { }
-
     public RealVectorParticleUpdater()
       : base() {
@@ -129,5 +129,4 @@
       Parameters.Add(new LookupParameter<DoubleValue>("NeighborBestAttraction", "The weight for the global best position."));
     }
-
     #endregion
   }
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs	(revision 5591)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs	(revision 5592)
@@ -33,4 +33,5 @@
   [StorableClass]
   public sealed class RealVectorSwarmUpdater : SingleSuccessorOperator, IRealVectorSwarmUpdater {
+
     public override bool CanChangeName {
       get { return false; }
@@ -79,4 +80,5 @@
     private DoubleValue BestQuality {
       get { return BestQualityParameter.ActualValue; }
+      set { BestQualityParameter.ActualValue = value; }
     }
     private RealVector BestPoint {
@@ -149,46 +151,38 @@
 
     public override IOperation Apply() {
-      InitializeBestPoint();
-      UpdateNeighbors();
-      UpdateSwarm();
-      if (VelocityBoundsUpdater != null) {
-        var ops = new OperationCollection();
-        ops.Add(ExecutionContext.CreateChildOperation(VelocityBoundsUpdater));
-        ops.Add(ExecutionContext.CreateOperation(Successor));
-        return ops;
-      } else {
-        return base.Apply();
-      }
-    }
-
-    private void InitializeBestPoint() {
+      UpdateGlobalBest();
+      UpdateNeighborBest();
+      UpdatePersonalBest();
+      return UpdateVelocityBounds();
+    }
+
+    private void UpdateGlobalBest() {
       if (BestQuality == null)
-        BestQualityParameter.ActualValue = new DoubleValue();
+        BestQuality = new DoubleValue();
       BestQuality.Value = Maximization ? Quality.Max(v => v.Value) : Quality.Min(v => v.Value);
-      int bestIndex = Quality.FindIndex(v => v.Value == BestQuality.Value);
-      BestPoint = (RealVector)RealVector[bestIndex].Clone();
-    }
-
-    private void UpdateNeighbors() {
-      if (Neighbors != null & Neighbors.Length > 0) {
-        if (this.NeighborBest == null || NeighborBest.Length != Neighbors.Length)
-          NeighborBest = new ItemArray<RealVector>(Neighbors.Length);
+      BestPoint = (RealVector)RealVector[Quality.FindIndex(v => v.Value == BestQuality.Value)].Clone();
+    }
+
+    private void UpdateNeighborBest() {
+      if (Neighbors.Length > 0) {
+        var neighborBest = new ItemArray<RealVector>(Neighbors.Length);
+        var neighborBestQuality = new ItemArray<DoubleValue>(Neighbors.Length);
         for (int n = 0; n < Neighbors.Length; n++) {
           var pairs = Quality.Zip(RealVector, (q, p) => new { Quality = q, Point = p })
             .Where((p, i) => i == n || Neighbors[n].Contains(i));
-          NeighborBest[n] = Maximization ?
-          pairs.OrderByDescending(p => p.Quality.Value).First().Point :
-          pairs.OrderBy(p => p.Quality.Value).First().Point;
+          var bestNeighbor = Maximization ?
+            pairs.OrderByDescending(p => p.Quality.Value).First() :
+            pairs.OrderBy(p => p.Quality.Value).First();
+          neighborBest[n] = bestNeighbor.Point;
+          neighborBestQuality[n] = bestNeighbor.Quality;
         }
-        NeighborBestParameter.ActualValue = NeighborBest;
+        NeighborBest = neighborBest;
+        NeighborBestQuality = neighborBestQuality;
       }
     }
 
-    private void UpdateSwarm() {
-      if (PersonalBestQuality.Length == 0) {
+    private void UpdatePersonalBest() {
+      if (PersonalBestQuality.Length == 0)
         PersonalBestQuality = (ItemArray<DoubleValue>)Quality.Clone();
-        if (VelocityBounds == null)
-          VelocityBounds = new DoubleMatrix(new double[,] { { -1, 1 } });
-      }
       for (int i = 0; i < RealVector.Length; i++) {
         if (Maximization && Quality[i].Value > PersonalBestQuality[i].Value ||
@@ -198,21 +192,15 @@
         }
       }
-      if (Neighbors.Length > 0) {
-        var neighborBestQuality = NeighborBestQuality;
-        var neighborBest = NeighborBest;
-        if (NeighborBestQuality.Length == 0) {
-          neighborBestQuality = (ItemArray<DoubleValue>)Quality.Clone();
-          neighborBest = (ItemArray<RealVector>)RealVector.Clone();
-        }
-        for (int i = 0; i < RealVector.Length; i++) {
-          if (Maximization && PersonalBestQuality[i].Value > neighborBestQuality[i].Value ||
-             !Maximization && PersonalBestQuality[i].Value < neighborBestQuality[i].Value) {
-            neighborBestQuality[i].Value = PersonalBestQuality[i].Value;
-            neighborBest[i] = PersonalBest[i];
-          }
-        }
-        NeighborBestQuality = neighborBestQuality;
-        NeighborBest = neighborBest;
-      }
+    }
+
+    private IOperation UpdateVelocityBounds() {
+      if (VelocityBounds == null)
+        VelocityBounds = new DoubleMatrix(new double[,] { { -1, 1 } });
+      return VelocityBoundsUpdater == null ?
+        base.Apply() :
+        new OperationCollection() { 
+          ExecutionContext.CreateChildOperation(VelocityBoundsUpdater),
+          ExecutionContext.CreateOperation(Successor)
+        };
     }
   }
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorTotallyConnectedParticleUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorTotallyConnectedParticleUpdater.cs	(revision 5591)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorTotallyConnectedParticleUpdater.cs	(revision 5592)
@@ -31,31 +31,30 @@
 
     #region Construction & Cloning
-
     [StorableConstructor]
     private RealVectorTotallyConnectedParticleUpdater(bool deserializing) : base(deserializing) { }
     private RealVectorTotallyConnectedParticleUpdater(RealVectorTotallyConnectedParticleUpdater original, Cloner cloner) : base(original, cloner) { }
     public RealVectorTotallyConnectedParticleUpdater() : base() { }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new RealVectorTotallyConnectedParticleUpdater(this, cloner);
     }
-
     #endregion
 
     public override IOperation Apply() {
-      base.Apply();
+      double inertia = Inertia.Value;
+      double personalBestAttraction = PersonalBestAttraction.Value;
+      double neighborBestAttraction = NeighborBestAttraction.Value;
+
       RealVector velocity = new RealVector(Velocity.Length);
       RealVector position = new RealVector(RealVector.Length);
       double r_p = Random.NextDouble();
       double r_g = Random.NextDouble();
-      double omega = Inertia.Value;
-      double phi_p = PersonalBestAttraction.Value;
-      double phi_g = NeighborBestAttraction.Value;
+
       for (int i = 0; i < velocity.Length; i++) {
         velocity[i] =
-          Velocity[i] * omega +
-          (PersonalBest[i] - RealVector[i]) * phi_p * r_p +
-          (BestPoint[i] - RealVector[i]) * phi_g * r_g;
+          Velocity[i] * inertia +
+          (PersonalBest[i] - RealVector[i]) * personalBestAttraction * r_p +
+          (BestPoint[i] - RealVector[i]) * neighborBestAttraction * r_g;
       }
+
       BoundsChecker.Apply(velocity, VelocityBounds);
       for (int i = 0; i < velocity.Length; i++) {
@@ -63,4 +62,5 @@
       }
       BoundsChecker.Apply(position, Bounds);
+
       RealVector = position;
       Velocity = velocity;
