Index: /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs	(revision 5568)
@@ -26,5 +26,4 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -78,6 +77,6 @@
       get { return (IValueParameter<DoubleValue>)Parameters["PersonalBestAttraction"]; }
     }
-    public IValueParameter<DoubleValue> NeighborsBestAttractionParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters["NeighborsBestAttraction"]; }
+    public IValueParameter<DoubleValue> NeighborBestAttractionParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["NeighborBestAttraction"]; }
     }
     public IValueParameter<MultiAnalyzer> AnalyzerParameter {
@@ -99,4 +98,8 @@
       get { return (OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["InertiaUpdater"]; }
     }
+    public ConstrainedValueParameter<ISwarmUpdater> SwarmUpdaterParameter {
+      get { return (ConstrainedValueParameter<ISwarmUpdater>)Parameters["SwarmUpdater"]; }
+
+    }
     #endregion
 
@@ -113,7 +116,4 @@
     [Storable]
     private ParticleSwarmOptimizationMainLoop mainLoop;
-
-    [Storable]
-    private CombinedOperator swarmUpdater;
 
     public ITopologyInitializer TopologyInitializer {
@@ -145,5 +145,4 @@
       solutionsCreator = cloner.Clone(original.solutionsCreator);
       mainLoop = cloner.Clone(original.mainLoop);
-      swarmUpdater = cloner.Clone(original.swarmUpdater); 
       Initialize();
     }
@@ -157,5 +156,5 @@
       Parameters.Add(new ValueParameter<DoubleValue>("Inertia", "Inertia weight on a particle's movement (omega).", new DoubleValue(-0.2)));
       Parameters.Add(new ValueParameter<DoubleValue>("PersonalBestAttraction", "Weight for particle's pull towards its personal best soution (phi_p).", new DoubleValue(-0.01)));
-      Parameters.Add(new ValueParameter<DoubleValue>("NeighborsBestAttraction", "Weight for pull towards the neighborhood best solution or global best solution in case of a totally connected topology (phi_g).", new DoubleValue(3.7)));
+      Parameters.Add(new ValueParameter<DoubleValue>("NeighborBestAttraction", "Weight for pull towards the neighborhood best solution or global best solution in case of a totally connected topology (phi_g).", new DoubleValue(3.7)));
       Parameters.Add(new ConstrainedValueParameter<IParticleCreator>("ParticleCreator", "Operator creates a new particle."));
       Parameters.Add(new ConstrainedValueParameter<IParticleUpdater>("ParticleUpdater", "Operator that updates a particle."));
@@ -163,4 +162,5 @@
       Parameters.Add(new OptionalConstrainedValueParameter<ITopologyUpdater>("TopologyUpdater", "Updates the neighborhood description vectors."));
       Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("InertiaUpdater", "Updates the omega parameter."));
+      Parameters.Add(new ConstrainedValueParameter<ISwarmUpdater>("SwarmUpdater", "Encoding-specific parameter which is provided by the problem. May provide additional encoding-specific parameters, such as velocity bounds for real valued problems"));
 
       RandomCreator randomCreator = new RandomCreator();
@@ -168,7 +168,5 @@
       solutionsCreator = new SolutionsCreator();
       Placeholder topologyInitializerPlaceholder = new Placeholder();
-      ResultsCollector resultsCollector = new ResultsCollector(); 
       Placeholder analyzerPlaceholder = new Placeholder();
-      swarmUpdater = new CombinedOperator();
       mainLoop = new ParticleSwarmOptimizationMainLoop();
 
@@ -183,32 +181,24 @@
 
       solutionsCreator.NumberOfSolutionsParameter.ActualName = "SwarmSize";
-      ParameterizeSolutionsCreator(); 
-      solutionsCreator.Successor = topologyInitializerPlaceholder; 
+      ParameterizeSolutionsCreator();
+      solutionsCreator.Successor = topologyInitializerPlaceholder;
 
       topologyInitializerPlaceholder.Name = "(TopologyInitializer)";
       topologyInitializerPlaceholder.OperatorParameter.ActualName = "TopologyInitializer";
-      topologyInitializerPlaceholder.Successor = swarmUpdater;
-
-      swarmUpdater.Successor = resultsCollector;
-
-      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations", null, "CurrentIteration"));
-      //resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Current Inertia", null, "Inertia"));
-      //resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
-      resultsCollector.ResultsParameter.ActualName = "Results";
-      resultsCollector.Successor = mainLoop;
+      topologyInitializerPlaceholder.Successor = mainLoop;
 
       mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
       mainLoop.InertiaParameter.ActualName = InertiaParameter.Name;
       mainLoop.MaxIterationsParameter.ActualName = MaxIterationsParameter.Name;
-      mainLoop.NeighborsBestAttractionParameter.ActualName = NeighborsBestAttractionParameter.Name;
+      mainLoop.NeighborBestAttractionParameter.ActualName = NeighborBestAttractionParameter.Name;
       mainLoop.InertiaUpdaterParameter.ActualName = InertiaUpdaterParameter.Name;
       mainLoop.ParticleUpdaterParameter.ActualName = ParticleUpdaterParameter.Name;
       mainLoop.PersonalBestAttractionParameter.ActualName = PersonalBestAttractionParameter.Name;
       mainLoop.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
-      mainLoop.SwarmSizeParameter.ActualName = SwarmSizeParameter.Name; 
-      mainLoop.TopologyUpdaterParameter.ActualName = TopologyUpdaterParameter.Name; 
+      mainLoop.SwarmSizeParameter.ActualName = SwarmSizeParameter.Name;
+      mainLoop.TopologyUpdaterParameter.ActualName = TopologyUpdaterParameter.Name;
       mainLoop.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
       mainLoop.ResultsParameter.ActualName = "Results";
-     // mainLoop.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
+      // mainLoop.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
 
       InitializeAnalyzers();
@@ -216,5 +206,5 @@
       InitializeParticleCreator();
       InitializeSwarmUpdater();
-      ParameterizeSolutionsCreator(); 
+      ParameterizeSolutionsCreator();
       UpdateAnalyzers();
       UpdateInertiaUpdater();
@@ -222,5 +212,5 @@
       UpdateTopologyInitializer();
       Initialize();
-      ParameterizeMainLoop(); 
+      ParameterizeMainLoop();
     }
 
@@ -257,5 +247,5 @@
       InitializeParticleCreator();
       InitializeSwarmUpdater();
-      ParameterizeSolutionsCreator(); 
+      ParameterizeSolutionsCreator();
       base.OnProblemChanged();
     }
@@ -290,5 +280,5 @@
           IParticleCreator creator = ParticleCreatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldParticleCreator.GetType());
           if (creator != null) ParticleCreator = creator;
-        }  
+        }
       }
     }
@@ -400,5 +390,5 @@
 
     private void ParameterizeMainLoop() {
-      if (Problem != null) { 
+      if (Problem != null) {
         mainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
       }
@@ -408,5 +398,7 @@
       if (Problem != null) {
         ISwarmUpdater updater = Problem.Operators.OfType<ISwarmUpdater>().FirstOrDefault();
-        swarmUpdater.OperatorGraph.InitialOperator = updater;
+        SwarmUpdaterParameter.ValidValues.Clear();
+        SwarmUpdaterParameter.ValidValues.Add(updater);
+        SwarmUpdaterParameter.Value = updater;
       }
     }
Index: /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimizationMainLoop.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimizationMainLoop.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimizationMainLoop.cs	(revision 5568)
@@ -20,19 +20,12 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.Analysis;
-using HeuristicLab.Optimization;
-using HeuristicLab.Random;
-using HeuristicLab.Optimization.Operators;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
@@ -59,10 +52,10 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters["PersonalBestAttraction"]; }
     }
-    public IValueLookupParameter<DoubleValue> NeighborsBestAttractionParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["NeighborsBestAttraction"]; }
+    public IValueLookupParameter<DoubleValue> NeighborBestAttractionParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["NeighborBestAttraction"]; }
     }
     public IValueLookupParameter<DoubleMatrix> VelocityBoundsParameter {
       get { return (IValueLookupParameter<DoubleMatrix>)Parameters["VelocityBounds"]; }
-    }                                     
+    }
     public IValueLookupParameter<IOperator> ParticleUpdaterParameter {
       get { return (IValueLookupParameter<IOperator>)Parameters["ParticleUpdater"]; }
@@ -74,12 +67,15 @@
       get { return (IValueLookupParameter<IOperator>)Parameters["InertiaUpdater"]; }
     }
-    public IValueLookupParameter<VariableCollection> ResultsParameter {
-      get { return (IValueLookupParameter<VariableCollection>)Parameters["Results"]; }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
     }
     public IValueLookupParameter<IOperator> EvaluatorParameter {
       get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
     }
+    public ValueLookupParameter<ISwarmUpdater> SwarmUpdaterParameter {
+      get { return (ValueLookupParameter<ISwarmUpdater>)Parameters["SwarmUpdater"]; }
+    }
     #endregion
-                                                                 
+
     public ParticleSwarmOptimizationMainLoop()
       : base() {
@@ -102,11 +98,11 @@
       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<IOperator>("Analyzer", "The operator used to analyze each generation."));
 
       Parameters.Add(new ValueLookupParameter<DoubleValue>("Inertia", "Inertia weight on a particle's movement (omega)."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("PersonalBestAttraction", "Weight for particle's pull towards its personal best soution (phi_p)."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("NeighborsBestAttraction", "Weight for pull towards the neighborhood best solution or global best solution in case of a totally connected topology (phi_g)."));
-     
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("NeighborBestAttraction", "Weight for pull towards the neighborhood best solution or global best solution in case of a totally connected topology (phi_g)."));
+
       Parameters.Add(new ValueLookupParameter<IOperator>("ParticleUpdater", "Operator that calculates new position and velocity of a particle"));
       Parameters.Add(new ValueLookupParameter<IOperator>("TopologyUpdater", "Updates the neighborhood description vectors"));
@@ -114,8 +110,12 @@
       Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "Evaluates a particle solution."));
 
-      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The variable collection where results should be stored."));
+
+      Parameters.Add(new ValueLookupParameter<ISwarmUpdater>("SwarmUpdater", "The encoding-specific swarm updater."));
       #endregion
 
       #region Create operators
+      ResultsCollector resultsCollector = new ResultsCollector();
+      Placeholder swarmUpdaterPlaceholer1 = new Placeholder();
       Placeholder evaluatorPlaceholder = new Placeholder();
       Placeholder analyzerPlaceholder = new Placeholder();
@@ -135,8 +135,17 @@
 
       #region Create operator graph
-      OperatorGraph.InitialOperator = analyzerPlaceholder;
+      OperatorGraph.InitialOperator = resultsCollector;
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations", null, "CurrentIteration"));
+      //resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Current Inertia", null, "Inertia"));
+      //resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
+      resultsCollector.ResultsParameter.ActualName = "Results";
+      resultsCollector.Successor = swarmUpdaterPlaceholer1;
+
+      swarmUpdaterPlaceholer1.Name = "(Swarm Updater)";
+      swarmUpdaterPlaceholer1.OperatorParameter.ActualName = SwarmUpdaterParameter.ActualName;
+      swarmUpdaterPlaceholer1.Successor = analyzerPlaceholder;
 
       analyzerPlaceholder.Name = "(Analyzer)";
-      analyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name; 
+      analyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
       analyzerPlaceholder.Successor = uniformSubScopeProcessor;
 
@@ -145,5 +154,5 @@
 
       particleUpdaterPlaceholder.Name = "(ParticleUpdater)";
-      particleUpdaterPlaceholder.OperatorParameter.ActualName = ParticleUpdaterParameter.Name; 
+      particleUpdaterPlaceholder.OperatorParameter.ActualName = ParticleUpdaterParameter.Name;
 
       evaluationProcessor.Parallel = new BoolValue(true);
@@ -152,21 +161,21 @@
 
       evaluatorPlaceholder.Name = "(Evaluator)";
-      evaluatorPlaceholder.OperatorParameter.ActualName = EvaluatorParameter.Name; 
+      evaluatorPlaceholder.OperatorParameter.ActualName = EvaluatorParameter.Name;
 
       topologyUpdaterPlaceholder.Name = "(TopologyUpdater)";
-      topologyUpdaterPlaceholder.OperatorParameter.ActualName = TopologyUpdaterParameter.Name; 
+      topologyUpdaterPlaceholder.OperatorParameter.ActualName = TopologyUpdaterParameter.Name;
       topologyUpdaterPlaceholder.Successor = swarmUpdater;
 
       swarmUpdater.Name = "Swarm Updater";
-      swarmUpdater.OperatorParameter.ActualName = "SwarmUpdater"; 
-      swarmUpdater.Successor = currentIterationCounter;
+      swarmUpdater.OperatorParameter.ActualName = SwarmUpdaterParameter.ActualName;
+      swarmUpdater.Successor = inertiaUpdaterPlaceholder;
+
+      inertiaUpdaterPlaceholder.Name = "(Inertia Updater)";
+      inertiaUpdaterPlaceholder.OperatorParameter.ActualName = InertiaUpdaterParameter.ActualName;
+      inertiaUpdaterPlaceholder.Successor = currentIterationCounter;
 
       currentIterationCounter.Name = "CurrentIteration++";
       currentIterationCounter.ValueParameter.ActualName = "CurrentIteration";
-      currentIterationCounter.Successor = inertiaUpdaterPlaceholder;
-
-      inertiaUpdaterPlaceholder.Name = "(Inertia Updater)";
-      inertiaUpdaterPlaceholder.OperatorParameter.ActualName = InertiaUpdaterParameter.ActualName; 
-      inertiaUpdaterPlaceholder.Successor = currentIterationComparator;
+      currentIterationCounter.Successor = currentIterationComparator;
 
       currentIterationComparator.LeftSideParameter.ActualName = "CurrentIteration";
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleUpdater.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleUpdater.cs	(revision 5568)
@@ -31,5 +31,5 @@
     ILookupParameter<DoubleMatrix> BoundsParameter { get; }
     ILookupParameter<RealVector> PersonalBestParameter { get; }
-    ILookupParameter<RealVector> NeighborsBestParameter { get; }
+    ILookupParameter<RealVector> NeighborBestParameter { get; }
   }
 }
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorSwarmUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorSwarmUpdater.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorSwarmUpdater.cs	(revision 5568)
@@ -25,5 +25,5 @@
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   public interface IRealVectorSwarmUpdater : ISwarmUpdater, IRealVectorOperator {
-    IScopeTreeLookupParameter<RealVector> NeighborsBestParameter { get; }
+    IScopeTreeLookupParameter<RealVector> NeighborBestParameter { get; }
     IScopeTreeLookupParameter<RealVector> PersonalBestParameter { get; }
     IScopeTreeLookupParameter<RealVector> RealVectorParameter { get; }
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorNeighborhoodParticleUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorNeighborhoodParticleUpdater.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorNeighborhoodParticleUpdater.cs	(revision 5568)
@@ -22,7 +22,6 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
@@ -47,10 +46,10 @@
       double omega = Inertia.Value;
       double phi_p = PersonalBestAttraction.Value;
-      double phi_g = NeighborsBestAttraction.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 +
-          (NeighborsBest[i] - RealVector[i]) * phi_g * r_g;
+          (BestPoint[i] - RealVector[i]) * phi_g * r_g;
       }
       BoundsChecker.Apply(velocity, VelocityBounds);
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs	(revision 5568)
@@ -45,6 +45,9 @@
       get { return (ILookupParameter<RealVector>)Parameters["PersonalBest"]; }
     }
-    public ILookupParameter<RealVector> NeighborsBestParameter {
-      get { return (ILookupParameter<RealVector>)Parameters["NeighborsBest"]; }
+    public ILookupParameter<RealVector> NeighborBestParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["NeighborBest"]; }
+    }
+    public LookupParameter<RealVector> BestPointParameter {
+      get { return (LookupParameter<RealVector>)Parameters["BestPoint"]; }
     }
     public ILookupParameter<RealVector> RealVectorParameter {
@@ -63,6 +66,6 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["PersonalBestAttraction"]; }
     }
-    public ILookupParameter<DoubleValue> NeighborsBestAttractionParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["NeighborsBestAttraction"]; }
+    public ILookupParameter<DoubleValue> NeighborBestAttractionParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["NeighborBestAttraction"]; }
     }
     #endregion
@@ -79,10 +82,13 @@
       get { return PersonalBestParameter.ActualValue; }
     }
+    protected RealVector BestPoint {
+      get { return BestPointParameter.ActualValue; }
+    }
     protected RealVector RealVector {
       get { return RealVectorParameter.ActualValue; }
       set { RealVectorParameter.ActualValue = value; }
     }
-    protected RealVector NeighborsBest {
-      get { return NeighborsBestParameter.ActualValue; }
+    protected RealVector NeighborBest {
+      get { return NeighborBestParameter.ActualValue; }
     }
     protected DoubleMatrix Bounds {
@@ -98,6 +104,6 @@
       get { return PersonalBestAttractionParameter.ActualValue; }
     }
-    protected DoubleValue NeighborsBestAttraction {
-      get { return NeighborsBestAttractionParameter.ActualValue; }
+    protected DoubleValue NeighborBestAttraction {
+      get { return NeighborBestAttractionParameter.ActualValue; }
     }
     #endregion
@@ -108,5 +114,5 @@
     protected RealVectorParticleUpdater(bool deserializing) : base(deserializing) { }
     protected RealVectorParticleUpdater(RealVectorParticleUpdater original, Cloner cloner) : base(original, cloner) { }
-    
+
     public RealVectorParticleUpdater()
       : base() {
@@ -116,10 +122,10 @@
       Parameters.Add(new LookupParameter<RealVector>("PersonalBest", "Particle's personal best solution."));
       Parameters.Add(new LookupParameter<RealVector>("BestPoint", "Global best position."));
-      Parameters.Add(new LookupParameter<RealVector>("NeighborsBest", "Best neighboring solution."));
+      Parameters.Add(new LookupParameter<RealVector>("NeighborBest", "Best neighboring solution."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds for each dimension of the position vector for the current problem."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("VelocityBounds", "Upper and lower bounds for the particle's velocity vector."));
       Parameters.Add(new LookupParameter<DoubleValue>("Inertia", "The weight for the particle's velocity vector."));
       Parameters.Add(new LookupParameter<DoubleValue>("PersonalBestAttraction", "The weight for the particle's personal best position."));
-      Parameters.Add(new LookupParameter<DoubleValue>("NeighborsBestAttraction", "The weight for the global best position."));
+      Parameters.Add(new LookupParameter<DoubleValue>("NeighborBestAttraction", "The weight for the global best position."));
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs	(revision 5568)
@@ -25,4 +25,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -43,6 +44,6 @@
       get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["PersonalBestQuality"]; }
     }
-    public IScopeTreeLookupParameter<DoubleValue> NeighborsBestQualityParameter {
-      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["NeighborsBestQuality"]; }
+    public IScopeTreeLookupParameter<DoubleValue> NeighborBestQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["NeighborBestQuality"]; }
     }
     public IScopeTreeLookupParameter<RealVector> RealVectorParameter {
@@ -52,9 +53,9 @@
       get { return (IScopeTreeLookupParameter<RealVector>)Parameters["PersonalBest"]; }
     }
-    public IScopeTreeLookupParameter<RealVector> NeighborsBestParameter {
-      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["NeighborsBest"]; }
-    }
-    public IValueLookupParameter<BoolValue> MaximizationParameter {
-      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    public IScopeTreeLookupParameter<RealVector> NeighborBestParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["NeighborBest"]; }
+    }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
     public ILookupParameter<DoubleValue> BestQualityParameter {
@@ -66,4 +67,10 @@
     public IScopeTreeLookupParameter<IntArray> NeighborsParameter {
       get { return (IScopeTreeLookupParameter<IntArray>)Parameters["Neighbors"]; }
+    }
+    public ValueLookupParameter<IDiscreteDoubleMatrixModifier> VelocityBoundsUpdaterParameter {
+      get { return (ValueLookupParameter<IDiscreteDoubleMatrixModifier>)Parameters["VelocityBoundsUpdater"]; }
+    }
+    public LookupParameter<DoubleMatrix> VelocityBoundsParameter {
+      get { return (LookupParameter<DoubleMatrix>)Parameters["VelocityBounds"]; }
     }
     #endregion
@@ -82,7 +89,9 @@
     private ItemArray<DoubleValue> PersonalBestQuality {
       get { return PersonalBestQualityParameter.ActualValue; }
-    }
-    private ItemArray<DoubleValue> NeighborsBestQuality {
-      get { return NeighborsBestQualityParameter.ActualValue; }
+      set { PersonalBestQualityParameter.ActualValue = value; }
+    }
+    private ItemArray<DoubleValue> NeighborBestQuality {
+      get { return NeighborBestQualityParameter.ActualValue; }
+      set { NeighborBestQualityParameter.ActualValue = value; }
     }
     private ItemArray<RealVector> RealVector {
@@ -93,7 +102,7 @@
       set { PersonalBestParameter.ActualValue = value; }
     }
-    private ItemArray<RealVector> NeighborsBest {
-      get { return NeighborsBestParameter.ActualValue; }
-      set { NeighborsBestParameter.ActualValue = value; }
+    private ItemArray<RealVector> NeighborBest {
+      get { return NeighborBestParameter.ActualValue; }
+      set { NeighborBestParameter.ActualValue = value; }
     }
     private bool Maximization {
@@ -102,4 +111,11 @@
     private ItemArray<IntArray> Neighbors {
       get { return NeighborsParameter.ActualValue; }
+    }
+    private IDiscreteDoubleMatrixModifier VelocityBoundsUpdater {
+      get { return VelocityBoundsUpdaterParameter.ActualValue; }
+    }
+    private DoubleMatrix VelocityBounds {
+      get { return VelocityBoundsParameter.ActualValue; }
+      set { VelocityBoundsParameter.ActualValue = value; }
     }
     #endregion
@@ -116,10 +132,12 @@
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "Particle's quality"));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("PersonalBestQuality", "Particle's personal best quality"));
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("NeighborsBestQuality", "Global best particle quality"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("NeighborBestQuality", "Global best particle quality"));
       Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "Particle's position"));
       Parameters.Add(new ScopeTreeLookupParameter<RealVector>("PersonalBest", "Particle's personal best position"));
-      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("NeighborsBest", "Neighborhood (or global in case of totally connected neighborhood) best particle position"));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("NeighborBest", "Neighborhood (or global in case of totally connected neighborhood) best particle position"));
       Parameters.Add(new ScopeTreeLookupParameter<IntArray>("Neighbors", "The list of neighbors for each particle."));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ValueLookupParameter<IDiscreteDoubleMatrixModifier>("VelocityBoundsUpdater", "Modifies the velocity bounds in the course of optimization."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("VelocityBounds", "Maximum velocity for each dimension."));
     }
 
@@ -132,8 +150,14 @@
     public override IOperation Apply() {
       InitializeBestPoint();
+      UpdateNeighbors();
       UpdateSwarm();
-      UpdateNeighbors();
-      UpdateVelocityBounds();
-      return base.Apply();
+      if (VelocityBoundsUpdater != null) {
+        var ops = new OperationCollection();
+        ops.Add(ExecutionContext.CreateChildOperation(VelocityBoundsUpdater));
+        ops.Add(ExecutionContext.CreateOperation(Successor));
+        return ops;
+      } else {
+        return base.Apply();
+      }
     }
 
@@ -148,47 +172,23 @@
     private void UpdateNeighbors() {
       if (Neighbors != null & Neighbors.Length > 0) {
-        if (this.NeighborsBest == null || NeighborsBest.Length != Neighbors.Length)
-          NeighborsBest = new ItemArray<RealVector>(Neighbors.Length);
+        if (this.NeighborBest == null || NeighborBest.Length != Neighbors.Length)
+          NeighborBest = new ItemArray<RealVector>(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));
-          NeighborsBest[n] = Maximization ?
+          NeighborBest[n] = Maximization ?
           pairs.OrderByDescending(p => p.Quality.Value).First().Point :
           pairs.OrderBy(p => p.Quality.Value).First().Point;
         }
-        NeighborsBestParameter.ActualValue = NeighborsBest;
-      }
-    }
-
-    private void UpdateVelocityBounds() {
-      // ToDo: Add code
+        NeighborBestParameter.ActualValue = NeighborBest;
+      }
     }
 
     private void UpdateSwarm() {
       if (PersonalBestQuality.Length == 0) {
-        ItemArray<DoubleValue> personalBestQualities = new ItemArray<DoubleValue>(RealVector.Length);
-        for (int i = 0; i < RealVector.Length; i++) {
-          if (Maximization) {
-            personalBestQualities[i] = new DoubleValue(double.MinValue);
-          } else {
-            personalBestQualities[i] = new DoubleValue(double.MaxValue);
-          }
-        }
-        PersonalBestQualityParameter.ActualValue = personalBestQualities;
-      }
-      if (NeighborsBestQuality.Length == 0) {
-        if (NeighborsParameter != null && Neighbors.Length > 0) {
-          ItemArray<DoubleValue> neighborsBestQualities = new ItemArray<DoubleValue>(RealVector.Length);
-          for (int i = 0; i < RealVector.Length; i++) {
-            if (Maximization) {
-              neighborsBestQualities[i] = new DoubleValue(double.MinValue);
-            } else {
-              neighborsBestQualities[i] = new DoubleValue(double.MaxValue);
-            }
-          }
-          NeighborsBestQualityParameter.ActualValue = neighborsBestQualities;
-        }
-      }
-      ItemArray<RealVector> neighborsBest = new ItemArray<RealVector>(RealVector.Length);
+        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 ||
@@ -196,16 +196,24 @@
           PersonalBestQuality[i].Value = Quality[i].Value;
           PersonalBest[i] = RealVector[i];
-          if (Maximization && PersonalBestQuality[i].Value > NeighborsBestQuality[i].Value ||
-             !Maximization && PersonalBestQuality[i].Value < NeighborsBestQuality[i].Value) {
-            NeighborsBestQuality[i].Value = PersonalBestQuality[i].Value;
-            neighborsBest[i] = PersonalBest[i];
+        }
+      }
+      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];
           }
         }
-      }
-      if (NeighborsParameter != null && Neighbors.Length > 0) {
-        NeighborsBestParameter.ActualValue = neighborsBest;
-      }
-    }
-
+        NeighborBestQuality = neighborBestQuality;
+        NeighborBest = neighborBest;
+      }
+    }
   }
 }
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorTotallyConnectedParticleUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorTotallyConnectedParticleUpdater.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorTotallyConnectedParticleUpdater.cs	(revision 5568)
@@ -22,6 +22,6 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
@@ -51,10 +51,10 @@
       double omega = Inertia.Value;
       double phi_p = PersonalBestAttraction.Value;
-      double phi_g = NeighborsBestAttraction.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 +
-          (NeighborsBest[i] - RealVector[i]) * phi_g * r_g;
+          (BestPoint[i] - RealVector[i]) * phi_g * r_g;
       }
       BoundsChecker.Apply(velocity, VelocityBounds);
Index: /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IDiscreteDoubleMatrixModifier.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IDiscreteDoubleMatrixModifier.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IDiscreteDoubleMatrixModifier.cs	(revision 5568)
@@ -25,5 +25,5 @@
 
 namespace HeuristicLab.Optimization {
-  public interface IDiscreteDoubleMatrixModifier : IItem {
+  public interface IDiscreteDoubleMatrixModifier : IOperator {
     ILookupParameter<DoubleMatrix> ValueParameter { get; }
     ILookupParameter<DoubleValue> ScaleParameter { get; }
Index: /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IParticleUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IParticleUpdater.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/IParticleUpdater.cs	(revision 5568)
@@ -29,5 +29,5 @@
   public interface IParticleUpdater : IOperator {
     ILookupParameter<DoubleValue> InertiaParameter { get; }
-    ILookupParameter<DoubleValue> NeighborsBestAttractionParameter { get; }
+    ILookupParameter<DoubleValue> NeighborBestAttractionParameter { get; }
     ILookupParameter<DoubleValue> PersonalBestAttractionParameter { get; }
     ILookupParameter<IRandom> RandomParameter { get; }
Index: /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISwarmUpdater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISwarmUpdater.cs	(revision 5567)
+++ /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISwarmUpdater.cs	(revision 5568)
@@ -26,7 +26,7 @@
   public interface ISwarmUpdater : IOperator {
     IScopeTreeLookupParameter<DoubleValue> QualityParameter { get; }
-    IScopeTreeLookupParameter<DoubleValue> NeighborsBestQualityParameter { get; }
+    IScopeTreeLookupParameter<DoubleValue> NeighborBestQualityParameter { get; }
     IScopeTreeLookupParameter<DoubleValue> PersonalBestQualityParameter { get; }
-    IValueLookupParameter<BoolValue> MaximizationParameter { get; }
+    ILookupParameter<BoolValue> MaximizationParameter { get; }
   }
 }
