Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj	(revision 15277)
@@ -116,5 +116,14 @@
     <Compile Include="Creators\NormalDistributedRealVectorCreator.cs" />
     <Compile Include="Interfaces\IRealVectorMultiNeighborhoodShakingOperator.cs" />
+    <Compile Include="ParticleOperators\RealVectorNeighborhoodParticleUpdater.cs" />
     <Compile Include="ParticleOperators\RealVectorParticleCreator.cs" />
+    <Compile Include="ParticleOperators\RealVectorParticleUpdater.cs" />
+    <Compile Include="ParticleOperators\RealVectorSwarmUpdater.cs" />
+    <Compile Include="ParticleOperators\RealVectorTotallyConnectedParticleUpdater.cs" />
+    <Compile Include="ParticleOperators\SPSO2007VelocityInitializer.cs" />
+    <Compile Include="ParticleOperators\SPSOVelocityInitializer.cs" />
+    <Compile Include="ParticleOperators\SPSO2011ParticleUpdater.cs" />
+    <Compile Include="ParticleOperators\SPSO2007ParticleUpdater.cs" />
+    <Compile Include="ParticleOperators\SPSOParticleCreator.cs" />
     <Compile Include="Crossovers\BlendAlphaBetaCrossover.cs" />
     <Compile Include="Interfaces\IRealVectorManipulator.cs" />
@@ -128,8 +137,7 @@
     <Compile Include="Interfaces\IRealVectorSwarmUpdater.cs" />
     <Compile Include="Manipulators\SelfAdaptiveNormalAllPositionsManipulator.cs" />
-    <Compile Include="ParticleOperators\RealVectorNeighborhoodParticleUpdater.cs" />
-    <Compile Include="ParticleOperators\RealVectorParticleUpdater.cs" />
-    <Compile Include="ParticleOperators\RealVectorSwarmUpdater.cs" />
-    <Compile Include="ParticleOperators\RealVectorTotallyConnectedParticleUpdater.cs" />
+    <Compile Include="ParticleOperators\SPSOParticleUpdater.cs" />
+    <Compile Include="ParticleOperators\SPSO2011VelocityInitializer.cs" />
+    <Compile Include="ParticleOperators\SPSOSwarmUpdater.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="RealVectorCreator.cs" />
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleCreator.cs	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleCreator.cs	(revision 15277)
@@ -26,5 +26,4 @@
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   public interface IRealVectorParticleCreator : IParticleCreator, IRealVectorOperator {
-    ILookupParameter<IntValue> ProblemSizeParameter { get; }
     ILookupParameter<RealVector> RealVectorParameter { get; }
     ILookupParameter<RealVector> PersonalBestParameter { get; }
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleUpdater.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleUpdater.cs	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleUpdater.cs	(revision 15277)
@@ -27,5 +27,5 @@
   public interface IRealVectorParticleUpdater : IParticleUpdater, IRealVectorOperator {
     ILookupParameter<RealVector> VelocityParameter { get; }
-    ILookupParameter<DoubleMatrix> CurrentVelocityBoundsParameter { get; }
+    ILookupParameter<DoubleValue> CurrentMaxVelocityParameter { get; }
     ILookupParameter<RealVector> RealVectorParameter { get; }
     ILookupParameter<DoubleMatrix> BoundsParameter { get; }
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorNeighborhoodParticleUpdater.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorNeighborhoodParticleUpdater.cs	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorNeighborhoodParticleUpdater.cs	(revision 15277)
@@ -20,13 +20,16 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   [Item("Neighborhood Particle Updater", "Updates the particle's position using (among other things) the best neighbor's position. Point = Point + Velocity*Inertia + (PersonalBestPoint-Point)*Phi_P*r_p + (BestNeighborPoint-Point)*Phi_G*r_g.")]
   [StorableClass]
-  public sealed class RealVectorNeighborhoodParticleUpdater : RealVectorParticleUpdater, ILocalParticleUpdater {
+  [NonDiscoverableType]
+  [Obsolete("Use SPSO2011ParticleUpdater")]
+  internal sealed class RealVectorNeighborhoodParticleUpdater : RealVectorParticleUpdater {
 
     #region Construction & Cloning
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleCreator.cs	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleCreator.cs	(revision 15277)
@@ -20,15 +20,20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   [Item("RealVectorParticleCreator", "Creates a particle with position, zero velocity vector and personal best.")]
   [StorableClass]
-  public class RealVectorParticleCreator : AlgorithmOperator, IRealVectorParticleCreator {
+  [NonDiscoverableType]
+  [Obsolete("Use SPSOParticleCreator")]
+  internal class RealVectorParticleCreator : AlgorithmOperator, IRealVectorParticleCreator {
 
     #region Parameters
@@ -47,4 +52,7 @@
     public ILookupParameter<RealVector> VelocityParameter {
       get { return (ILookupParameter<RealVector>)Parameters["Velocity"]; }
+    }
+    public ILookupParameter<ISolutionCreator> SolutionCreatorParameter {
+      get { return (ILookupParameter<ISolutionCreator>)Parameters["SolutionCreator"]; }
     }
     #endregion
@@ -70,4 +78,5 @@
       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<ISolutionCreator>("SolutionCreator", "The operator that creates the initial position."));
 
       UniformRandomRealVectorCreator realVectorCreater = new UniformRandomRealVectorCreator();
@@ -94,6 +103,10 @@
       return base.Apply();
     }
-
-
+    
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("SolutionCreator"))
+        Parameters.Add(new LookupParameter<ISolutionCreator>("SolutionCreator", "The operator that creates the initial position."));
+    }
   }
 }
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs	(revision 15277)
@@ -27,4 +27,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
@@ -32,5 +33,7 @@
   [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 {
+  [NonDiscoverableType]
+  [Obsolete("Use SPSO2011ParticleUpdater")]
+  internal abstract class RealVectorParticleUpdater : SingleSuccessorOperator, IRealVectorParticleUpdater {
 
     public override bool CanChangeName {
@@ -62,4 +65,7 @@
     public ILookupParameter<DoubleMatrix> CurrentVelocityBoundsParameter {
       get { return (ILookupParameter<DoubleMatrix>)Parameters["CurrentVelocityBounds"]; }
+    }
+    public ILookupParameter<DoubleValue> CurrentMaxVelocityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["CurrentMaxVelocity"]; }
     }
     public ILookupParameter<DoubleValue> InertiaParameter {
@@ -126,4 +132,5 @@
       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>("CurrentVelocityBounds", "Upper and lower bounds for the particle's velocity vector."));
+      Parameters.Add(new LookupParameter<DoubleValue>("CurrentMaxVelocity", "Maximum for the particle's velocity vector."));
       Parameters.Add(new LookupParameter<DoubleValue>("CurrentInertia", "The weight for the particle's velocity vector."));
       Parameters.Add(new LookupParameter<DoubleValue>("PersonalBestAttraction", "The weight for the particle's personal best position."));
@@ -131,4 +138,10 @@
     }
     #endregion
+    
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("CurrentMaxVelocity"))
+        Parameters.Add(new LookupParameter<DoubleValue>("CurrentMaxVelocity", "Maximum for the particle's velocity vector."));
+    }
 
     protected void MoveParticle(RealVector velocity, RealVector position) {
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs	(revision 15277)
@@ -35,5 +35,7 @@
   [Item("RealVectorSwarmUpdater", "Updates personal best point and quality as well as global best point and quality.")]
   [StorableClass]
-  public sealed class RealVectorSwarmUpdater : SingleSuccessorOperator, IRealVectorSwarmUpdater, ISingleObjectiveOperator {
+  [NonDiscoverableType]
+  [Obsolete("Use SPSOSwarmUpdater")]
+  internal sealed class RealVectorSwarmUpdater : SingleSuccessorOperator, IRealVectorSwarmUpdater, ISingleObjectiveOperator {
 
     [Storable]
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorTotallyConnectedParticleUpdater.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorTotallyConnectedParticleUpdater.cs	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorTotallyConnectedParticleUpdater.cs	(revision 15277)
@@ -20,13 +20,16 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   [Item("Totally Connected Particle Updater", "Updates the particle's position using (among other things) the global best position. Use together with the empty topology initialzer. Point = Point + Velocity*Inertia + (PersonalBestPoint-Point)*Phi_P*r_p + (BestPoint-Point)*Phi_G*r_g")]
   [StorableClass]
-  public sealed class RealVectorTotallyConnectedParticleUpdater : RealVectorParticleUpdater, IGlobalParticleUpdater {
+  [NonDiscoverableType]
+  [Obsolete("Use SPSO2011ParticleUpdater")]
+  internal sealed class RealVectorTotallyConnectedParticleUpdater : RealVectorParticleUpdater {
 
     #region Construction & Cloning
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2007ParticleUpdater.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2007ParticleUpdater.cs	(revision 15277)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2007ParticleUpdater.cs	(revision 15277)
@@ -0,0 +1,100 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  [Item("SPSO 2007 Particle Updater", "Updates the particle's position according to the formulae described in SPSO 2007.")]
+  [StorableClass]
+  public sealed class SPSO2007ParticleUpdater : SPSOParticleUpdater {
+
+    #region Construction & Cloning
+    [StorableConstructor]
+    private SPSO2007ParticleUpdater(bool deserializing) : base(deserializing) { }
+    private SPSO2007ParticleUpdater(SPSO2007ParticleUpdater original, Cloner cloner) : base(original, cloner) { }
+    public SPSO2007ParticleUpdater() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SPSO2007ParticleUpdater(this, cloner);
+    }
+    #endregion
+    
+    public static void UpdateVelocity(IRandom random, RealVector velocity, RealVector position, RealVector personalBest, RealVector neighborBest, double inertia = 0.721, double personalBestAttraction = 1.193, double neighborBestAttraction = 1.193, double maxVelocity = double.MaxValue) {
+      for (int i = 0; i < velocity.Length; i++) {
+        double r_p = random.NextDouble();
+        double r_g = random.NextDouble();
+        velocity[i] =
+          velocity[i] * inertia +
+          (personalBest[i] - position[i]) * personalBestAttraction * r_p +
+          (neighborBest[i] - position[i]) * neighborBestAttraction * r_g;
+      }
+
+      var speed = Math.Sqrt(velocity.DotProduct(velocity));
+      if (speed > maxVelocity) {
+        for (var i = 0; i < velocity.Length; i++) {
+          velocity[i] *= maxVelocity / speed;
+        }
+      }
+    }
+
+    public static void UpdatePosition(DoubleMatrix bounds, RealVector velocity, RealVector position) {
+      for (int i = 0; i < velocity.Length; i++) {
+        position[i] += velocity[i];
+      }
+
+      for (int i = 0; i < position.Length; i++) {
+        double min = bounds[i % bounds.Rows, 0];
+        double max = bounds[i % bounds.Rows, 1];
+        if (position[i] < min) {
+          position[i] = min;
+          velocity[i] = 0; // SPSO 2007
+        }
+        if (position[i] > max) {
+          position[i] = max;
+          velocity[i] = 0; // SPSO 2007
+        }
+      }
+    }
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var velocity = VelocityParameter.ActualValue;
+      var maxVelocity = CurrentMaxVelocityParameter.ActualValue.Value;
+      var position = RealVectorParameter.ActualValue;
+      var bounds = BoundsParameter.ActualValue;
+
+      var inertia = CurrentInertiaParameter.ActualValue.Value;
+      var personalBest = PersonalBestParameter.ActualValue;
+      var personalBestAttraction = PersonalBestAttractionParameter.ActualValue.Value;
+      var neighborBest = NeighborBestParameter.ActualValue;
+      var neighborBestAttraction = NeighborBestAttractionParameter.ActualValue.Value;
+
+      UpdateVelocity(random, velocity, position, personalBest, neighborBest, inertia, personalBestAttraction, neighborBestAttraction, maxVelocity);
+      UpdatePosition(bounds, velocity, position);
+
+      return base.Apply();
+    }
+  }
+}
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2007VelocityInitializer.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2007VelocityInitializer.cs	(revision 15277)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2007VelocityInitializer.cs	(revision 15277)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2017 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  [Item("Velocity Initializer (SPSO 2007)", "Initializes the velocity vector.")]
+  [StorableClass]
+  public class SPSO2007VelocityInitializer : SPSOVelocityInitializer {
+    
+    #region Construction & Cloning
+    [StorableConstructor]
+    protected SPSO2007VelocityInitializer(bool deserializing) : base(deserializing) { }
+    protected SPSO2007VelocityInitializer(SPSO2007VelocityInitializer original, Cloner cloner) : base(original, cloner) { }
+    public SPSO2007VelocityInitializer() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SPSO2007VelocityInitializer(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var bounds = BoundsParameter.ActualValue;
+      var position = RealVectorParameter.ActualValue;
+      var velocity = new RealVector(position.Length);
+      for (var i = 0; i < velocity.Length; i++) {
+        var lower = bounds[i % bounds.Rows, 0];
+        var upper = bounds[i % bounds.Rows, 1];
+        velocity[i] = (lower + random.NextDouble() * (upper - lower) - position[i]) / 2.0; // SPSO 2007
+      }
+      VelocityParameter.ActualValue = velocity;
+      return base.Apply();
+    }
+  }
+}
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2011ParticleUpdater.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2011ParticleUpdater.cs	(revision 15277)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2011ParticleUpdater.cs	(revision 15277)
@@ -0,0 +1,119 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  [Item("SPSO 2011 Particle Updater", "Updates the particle's position according to the formulae described in SPSO 2011.")]
+  [StorableClass]
+  public sealed class SPSO2011ParticleUpdater : SPSOParticleUpdater {
+    #region Construction & Cloning
+    [StorableConstructor]
+    private SPSO2011ParticleUpdater(bool deserializing) : base(deserializing) { }
+    private SPSO2011ParticleUpdater(SPSO2011ParticleUpdater original, Cloner cloner) : base(original, cloner) { }
+    public SPSO2011ParticleUpdater() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SPSO2011ParticleUpdater(this, cloner);
+    }
+    #endregion
+    
+    public static void UpdateVelocity(IRandom random, RealVector velocity, RealVector position, RealVector personalBest, RealVector neighborBest, double inertia = 0.721, double personalBestAttraction = 1.193, double neighborBestAttraction = 1.193, double maxVelocity = double.MaxValue) {
+      var gravity = new double[velocity.Length];
+      var direction = new RealVector(velocity.Length);
+      var radius = 0.0;
+
+      var nd = new NormalDistributedRandom(random, 0, 1);
+
+      for (int i = 0; i < velocity.Length; i++) {
+        var g_id = (personalBestAttraction * personalBest[i]
+          + neighborBestAttraction * neighborBest[i]
+          - position[i] * (neighborBestAttraction + personalBestAttraction)) / 3.0;
+        // center of the hyper-sphere
+        gravity[i] = g_id + position[i];
+        // a random direction vector uniform over the surface of hyper-sphere, see http://mathworld.wolfram.com/HyperspherePointPicking.html
+        direction[i] = nd.NextDouble();
+        radius += g_id * g_id;
+      }
+
+      // randomly choose a radius within the hyper-sphere
+      radius = random.NextDouble() * Math.Sqrt(radius);
+
+      // unitscale is used to rescale the random direction vector to unit length, resp. length of the radius
+      var unitscale = Math.Sqrt(direction.DotProduct(direction));
+      if (unitscale > 0) {
+        for (var i = 0; i < velocity.Length; i++) {
+          var sampledPos = gravity[i] + direction[i] * radius / unitscale;
+          velocity[i] = velocity[i] * inertia + sampledPos - position[i];
+        }
+      }
+
+      var speed = Math.Sqrt(velocity.DotProduct(velocity));
+      if (speed > maxVelocity) {
+        for (var i = 0; i < velocity.Length; i++) {
+          velocity[i] *= maxVelocity / speed;
+        }
+      }
+    }
+
+    public static void UpdatePosition(DoubleMatrix bounds, RealVector velocity, RealVector position) {
+      for (int i = 0; i < velocity.Length; i++) {
+        position[i] += velocity[i];
+      }
+
+      for (int i = 0; i < position.Length; i++) {
+        double min = bounds[i % bounds.Rows, 0];
+        double max = bounds[i % bounds.Rows, 1];
+        if (position[i] < min) {
+          position[i] = min;
+          velocity[i] = -0.5 * velocity[i];
+        }
+        if (position[i] > max) {
+          position[i] = max;
+          velocity[i] = -0.5 * velocity[i];
+        }
+      }
+    }
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var velocity = VelocityParameter.ActualValue;
+      var maxVelocity = CurrentMaxVelocityParameter.ActualValue.Value;
+      var position = RealVectorParameter.ActualValue;
+      var bounds = BoundsParameter.ActualValue;
+
+      var inertia = CurrentInertiaParameter.ActualValue.Value;
+      var personalBest = PersonalBestParameter.ActualValue;
+      var personalBestAttraction = PersonalBestAttractionParameter.ActualValue.Value;
+      var neighborBest = NeighborBestParameter.ActualValue;
+      var neighborBestAttraction = NeighborBestAttractionParameter.ActualValue.Value;
+
+      UpdateVelocity(random, velocity, position, personalBest, neighborBest, inertia, personalBestAttraction, neighborBestAttraction, maxVelocity);
+      UpdatePosition(bounds, velocity, position);
+
+      return base.Apply();
+    }
+  }
+}
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2011VelocityInitializer.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2011VelocityInitializer.cs	(revision 15277)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSO2011VelocityInitializer.cs	(revision 15277)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2017 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  [Item("Velocity Initializer (SPSO 2011)", "Initializes the velocity vector.")]
+  [StorableClass]
+  public class SPSO2011VelocityInitializer : SPSOVelocityInitializer {
+    
+    #region Construction & Cloning
+    [StorableConstructor]
+    protected SPSO2011VelocityInitializer(bool deserializing) : base(deserializing) { }
+    protected SPSO2011VelocityInitializer(SPSO2011VelocityInitializer original, Cloner cloner) : base(original, cloner) { }
+    public SPSO2011VelocityInitializer() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SPSO2011VelocityInitializer(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var bounds = BoundsParameter.ActualValue;
+      var position = RealVectorParameter.ActualValue;
+      var velocity = new RealVector(position.Length);
+      for (var i = 0; i < velocity.Length; i++) {
+        var lower = (bounds[i % bounds.Rows, 0] - position[i]);
+        var upper = (bounds[i % bounds.Rows, 1] - position[i]);
+        velocity[i] = lower + random.NextDouble() * (upper - lower); // SPSO 2011
+      }
+      VelocityParameter.ActualValue = velocity;
+      return base.Apply();
+    }
+  }
+}
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOParticleCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOParticleCreator.cs	(revision 15277)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOParticleCreator.cs	(revision 15277)
@@ -0,0 +1,105 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  [Item("Particle Creator (SPSO)", "Creates a particle with position, velocity vector and personal best.")]
+  [StorableClass]
+  public class SPSOParticleCreator : AlgorithmOperator, IRealVectorParticleCreator, IStochasticOperator {
+
+    #region Parameters
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    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 ILookupParameter<RealVector> VelocityParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["Velocity"]; }
+    }
+    public ILookupParameter<ISolutionCreator> SolutionCreatorParameter {
+      get { return (ILookupParameter<ISolutionCreator>)Parameters["SolutionCreator"]; }
+    }
+    public IConstrainedValueParameter<SPSOVelocityInitializer> VelocityInitializerParameter {
+      get { return (IConstrainedValueParameter<SPSOVelocityInitializer>)Parameters["VelocityInitializer"]; }
+    }
+    #endregion
+    
+    #region Construction & Cloning
+    [StorableConstructor]
+    protected SPSOParticleCreator(bool deserializing) : base(deserializing) { }
+    protected SPSOParticleCreator(SPSOParticleCreator original, Cloner cloner) : base(original, cloner) { }
+    public SPSOParticleCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      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<ISolutionCreator>("SolutionCreator", "The operator that creates the initial position."));
+      Parameters.Add(new ConstrainedValueParameter<SPSOVelocityInitializer>("VelocityInitializer", "The initialization of the velocity vector."));
+
+      VelocityInitializerParameter.ValidValues.Add(new SPSO2011VelocityInitializer());
+      VelocityInitializerParameter.ValidValues.Add(new SPSO2007VelocityInitializer());
+
+      foreach (var init in VelocityInitializerParameter.ValidValues) {
+        init.BoundsParameter.ActualName = BoundsParameter.Name;
+        init.BoundsParameter.Hidden = true;
+        init.RandomParameter.ActualName = RandomParameter.Name;
+        init.RealVectorParameter.ActualName = RealVectorParameter.Name;
+        init.VelocityParameter.ActualName = VelocityParameter.Name;
+      }
+
+      Placeholder realVectorCreater = new Placeholder();
+      Assigner personalBestPositionAssigner = new Assigner();
+      Placeholder velocityInitializer = new Placeholder();
+
+      OperatorGraph.InitialOperator = realVectorCreater;
+
+      realVectorCreater.OperatorParameter.ActualName = SolutionCreatorParameter.Name;
+      realVectorCreater.Successor = personalBestPositionAssigner;
+
+      personalBestPositionAssigner.LeftSideParameter.ActualName = PersonalBestParameter.Name;
+      personalBestPositionAssigner.RightSideParameter.ActualName = RealVectorParameter.Name;
+      personalBestPositionAssigner.Successor = velocityInitializer;
+
+      velocityInitializer.OperatorParameter.ActualName = VelocityInitializerParameter.Name;
+      velocityInitializer.Successor = null;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SPSOParticleCreator(this, cloner);
+    }
+    #endregion
+  }
+}
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOParticleUpdater.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOParticleUpdater.cs	(revision 15277)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOParticleUpdater.cs	(revision 15277)
@@ -0,0 +1,94 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+ 
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+
+  [Item("Particle Updater (SPSO)", "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 SPSOParticleUpdater : SingleSuccessorOperator, IRealVectorParticleUpdater {
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    #region Parameter properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<RealVector> VelocityParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["Velocity"]; }
+    }
+    public ILookupParameter<RealVector> PersonalBestParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["PersonalBest"]; }
+    }
+    public ILookupParameter<RealVector> NeighborBestParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["NeighborBest"]; }
+    }
+    public ILookupParameter<RealVector> RealVectorParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["RealVector"]; }
+    }
+    public ILookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+    public ILookupParameter<DoubleValue> CurrentMaxVelocityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["CurrentMaxVelocity"]; }
+    }
+    public ILookupParameter<DoubleValue> CurrentInertiaParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["CurrentInertia"]; }
+    }
+    ILookupParameter<DoubleValue> IParticleUpdater.InertiaParameter { get { return CurrentInertiaParameter; } }
+
+    public ILookupParameter<DoubleValue> PersonalBestAttractionParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["PersonalBestAttraction"]; }
+    }
+    public ILookupParameter<DoubleValue> NeighborBestAttractionParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["NeighborBestAttraction"]; }
+    }
+    #endregion
+
+    #region Construction & Cloning
+    [StorableConstructor]
+    protected SPSOParticleUpdater(bool deserializing) : base(deserializing) { }
+    protected SPSOParticleUpdater(SPSOParticleUpdater original, Cloner cloner) : base(original, cloner) { }
+    public SPSOParticleUpdater()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "Random number generator."));
+      Parameters.Add(new LookupParameter<RealVector>("RealVector", "Particle's current solution"));
+      Parameters.Add(new LookupParameter<RealVector>("Velocity", "Particle's current velocity."));
+      Parameters.Add(new LookupParameter<RealVector>("PersonalBest", "Particle's personal best 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<DoubleValue>("CurrentMaxVelocity", "Maximum for the particle's velocity vector."));
+      Parameters.Add(new LookupParameter<DoubleValue>("CurrentInertia", "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>("NeighborBestAttraction", "The weight for the global best position."));
+    }
+    #endregion
+  }
+}
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOSwarmUpdater.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOSwarmUpdater.cs	(revision 15277)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOSwarmUpdater.cs	(revision 15277)
@@ -0,0 +1,243 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  [Item("Swarm Updater (SPSO)", "Updates personal best point and quality as well as neighbor best point and quality.")]
+  [StorableClass]
+  public sealed class SPSOSwarmUpdater : SingleSuccessorOperator, IRealVectorSwarmUpdater, ISingleObjectiveOperator {
+
+    [Storable]
+    private ResultsCollector ResultsCollector;
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    #region Parameter properties
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> PersonalBestQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["PersonalBestQuality"]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> NeighborBestQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["NeighborBestQuality"]; }
+    }
+    public IScopeTreeLookupParameter<RealVector> RealVectorParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["RealVector"]; }
+    }
+    public IScopeTreeLookupParameter<RealVector> PersonalBestParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["PersonalBest"]; }
+    }
+    public IScopeTreeLookupParameter<RealVector> NeighborBestParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["NeighborBest"]; }
+    }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> SwarmBestQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["SwarmBestQuality"]; }
+    }
+    public ILookupParameter<RealVector> BestRealVectorParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["BestRealVector"]; }
+    }
+    public IScopeTreeLookupParameter<IntArray> NeighborsParameter {
+      get { return (IScopeTreeLookupParameter<IntArray>)Parameters["Neighbors"]; }
+    }
+    public IValueLookupParameter<DoubleValue> MaxVelocityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["MaxVelocity"]; }
+    }
+    public ILookupParameter<DoubleValue> CurrentMaxVelocityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["CurrentMaxVelocity"]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    #region Max Velocity Updating
+    public IConstrainedValueParameter<IDiscreteDoubleValueModifier> MaxVelocityScalingOperatorParameter {
+      get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["MaxVelocityScalingOperator"]; }
+    }
+    public IValueLookupParameter<DoubleValue> FinalMaxVelocityParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["FinalMaxVelocity"]; }
+    }
+    public ILookupParameter<IntValue> MaxVelocityIndexParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["MaxVelocityIndex"]; }
+    }
+    public IValueLookupParameter<IntValue> MaxVelocityStartIndexParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaxVelocityStartIndex"]; }
+    }
+    public IValueLookupParameter<IntValue> MaxVelocityEndIndexParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaxVelocityEndIndex"]; }
+    }
+    #endregion
+
+    #endregion
+    
+    #region Construction & Cloning
+
+    [StorableConstructor]
+    private SPSOSwarmUpdater(bool deserializing) : base(deserializing) { }
+    private SPSOSwarmUpdater(SPSOSwarmUpdater original, Cloner cloner)
+      : base(original, cloner) {
+      ResultsCollector = cloner.Clone(original.ResultsCollector);
+    }
+    public SPSOSwarmUpdater()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("SwarmBestQuality", "Swarm's best quality."));
+      Parameters.Add(new LookupParameter<RealVector>("BestRealVector", "Global best particle position."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "Particles' qualities."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("PersonalBestQuality", "Particles' personal best qualities."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("NeighborBestQuality", "Best neighbor particles' qualities."));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "Particles' positions."));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("PersonalBest", "Particles' personal best positions."));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("NeighborBest", "Neighborhood (or global in case of totally connected neighborhood) best particle positions."));
+      Parameters.Add(new ScopeTreeLookupParameter<IntArray>("Neighbors", "The list of neighbors for each particle."));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaxVelocity", "The maximum velocity for each particle and initial velocity if scaling is used.", new DoubleValue(double.MaxValue)));
+      Parameters.Add(new LookupParameter<DoubleValue>("CurrentMaxVelocity", "Current value of the speed limit."));
+      Parameters.Add(new LookupParameter<ResultCollection>("Results", "Results"));
+
+      #region Max Velocity Updating
+      Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("MaxVelocityScalingOperator", "Modifies the value"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("FinalMaxVelocity", "The value of maximum velocity if scaling is used and PSO has reached maximum iterations.", new DoubleValue(1E-10)));
+      Parameters.Add(new LookupParameter<IntValue>("MaxVelocityIndex", "The current index.", "Iterations"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaxVelocityStartIndex", "The start index at which to start modifying 'Value'.", new IntValue(0)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaxVelocityEndIndex", "The end index by which 'Value' should have reached 'EndValue'.", "MaxIterations"));
+      MaxVelocityStartIndexParameter.Hidden = true;
+      MaxVelocityEndIndexParameter.Hidden = true;
+      #endregion
+
+      Initialize();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SPSOSwarmUpdater(this, cloner);
+    }
+
+    #endregion
+
+    private void Initialize() {
+      ResultsCollector = new ResultsCollector();
+      ResultsCollector.CollectedValues.Add(CurrentMaxVelocityParameter);
+      ResultsCollector.CollectedValues.Add(MaxVelocityParameter);
+
+      foreach (IDiscreteDoubleValueModifier op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>()) {
+        MaxVelocityScalingOperatorParameter.ValidValues.Add(op);
+        op.ValueParameter.ActualName = CurrentMaxVelocityParameter.Name;
+        op.StartValueParameter.ActualName = MaxVelocityParameter.Name;
+        op.EndValueParameter.ActualName = FinalMaxVelocityParameter.Name;
+        op.IndexParameter.ActualName = MaxVelocityIndexParameter.Name;
+        op.StartIndexParameter.ActualName = MaxVelocityStartIndexParameter.Name;
+        op.EndIndexParameter.ActualName = MaxVelocityEndIndexParameter.Name;
+      }
+      MaxVelocityScalingOperatorParameter.Value = null;
+    }
+
+    public override IOperation Apply() {
+      var max = MaximizationParameter.ActualValue.Value;
+      // Update of the personal bests
+      var points = RealVectorParameter.ActualValue;
+      var qualities = QualityParameter.ActualValue;
+      var particles = points.Select((p, i) => new { Particle = p, Index = i })
+        .Zip(qualities, (p, q) => Tuple.Create(p.Index, p.Particle, q.Value)).ToList();
+      UpdatePersonalBest(max, particles);
+
+      // SPSO: update of the neighbor bests from the personal bests
+      var personalBestPoints = PersonalBestParameter.ActualValue;
+      var personalBestQualities = PersonalBestQualityParameter.ActualValue;
+      particles = personalBestPoints.Select((p, i) => new { Particle = p, Index = i })
+        .Zip(personalBestQualities, (p, q) => Tuple.Create(p.Index, p.Particle, q.Value)).ToList();
+      UpdateNeighborBest(max, particles);
+
+      var next = new OperationCollection() { base.Apply() };
+      next.Insert(0, ExecutionContext.CreateChildOperation(ResultsCollector));
+      if (MaxVelocityScalingOperatorParameter.Value != null) {
+        next.Insert(0, ExecutionContext.CreateChildOperation(MaxVelocityScalingOperatorParameter.Value));
+      } else CurrentMaxVelocityParameter.ActualValue = new DoubleValue(MaxVelocityParameter.ActualValue.Value);
+      return next;
+    }
+
+    private void UpdateNeighborBest(bool maximization, IList<Tuple<int, RealVector, double>> particles) {
+      var neighbors = NeighborsParameter.ActualValue;
+      if (neighbors.Length > 0) {
+        var neighborBest = new ItemArray<RealVector>(neighbors.Length);
+        var neighborBestQuality = new ItemArray<DoubleValue>(neighbors.Length);
+        double overallBest = double.NaN;
+        RealVector overallBestVector = null;
+        for (int n = 0; n < neighbors.Length; n++) {
+          var neighborhood = particles.Where(x => neighbors[n].Contains(x.Item1));
+          var bestNeighbor = (maximization ? neighborhood.MaxItems(p => p.Item3)
+                                           : neighborhood.MinItems(p => p.Item3)).First();
+          neighborBest[n] = bestNeighbor.Item2;
+          neighborBestQuality[n] = new DoubleValue(bestNeighbor.Item3);
+          if (double.IsNaN(overallBest) || maximization && bestNeighbor.Item3 > overallBest
+            || !maximization && bestNeighbor.Item3 < overallBest) {
+            overallBest = bestNeighbor.Item3;
+            overallBestVector = bestNeighbor.Item2;
+          }
+        }
+        NeighborBestParameter.ActualValue = neighborBest;
+        NeighborBestQualityParameter.ActualValue = neighborBestQuality;
+        SwarmBestQualityParameter.ActualValue = new DoubleValue(overallBest);
+        BestRealVectorParameter.ActualValue = overallBestVector;
+      } else {
+        // Neighbor best = Global best
+        var best = maximization ? particles.MaxItems(x => x.Item3).First() : particles.MinItems(x => x.Item3).First();
+        NeighborBestParameter.ActualValue = new ItemArray<RealVector>(Enumerable.Repeat(best.Item2, particles.Count));
+        NeighborBestQualityParameter.ActualValue = new ItemArray<DoubleValue>(Enumerable.Repeat(new DoubleValue(best.Item3), particles.Count));
+        SwarmBestQualityParameter.ActualValue = new DoubleValue(best.Item3);
+        BestRealVectorParameter.ActualValue = best.Item2;
+      }
+    }
+
+    private void UpdatePersonalBest(bool maximization, IList<Tuple<int, RealVector, double>> particles) {
+      var personalBest = PersonalBestParameter.ActualValue;
+      var personalBestQuality = PersonalBestQualityParameter.ActualValue;
+
+      if (personalBestQuality.Length == 0) {
+        personalBestQuality = new ItemArray<DoubleValue>(particles.Select(x => new DoubleValue(x.Item3)));
+        PersonalBestQualityParameter.ActualValue = personalBestQuality;
+      }
+      foreach (var p in particles) {
+        if (maximization && p.Item3 > personalBestQuality[p.Item1].Value ||
+          !maximization && p.Item3 < personalBestQuality[p.Item1].Value) {
+          personalBestQuality[p.Item1].Value = p.Item3;
+          personalBest[p.Item1] = new RealVector(p.Item2);
+        }
+      }
+      PersonalBestParameter.ActualValue = personalBest;
+    }
+  }
+}
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOVelocityInitializer.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOVelocityInitializer.cs	(revision 15277)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/SPSOVelocityInitializer.cs	(revision 15277)
@@ -0,0 +1,62 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2017 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  [Item("Velocity Initializer (SPSO)", "Initializes the velocity vector.")]
+  [StorableClass]
+  public abstract class SPSOVelocityInitializer : SingleSuccessorOperator, IStochasticOperator {
+    #region Parameters
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+    public ILookupParameter<RealVector> RealVectorParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["RealVector"]; }
+    }
+    public ILookupParameter<RealVector> VelocityParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["Velocity"]; }
+    }
+    #endregion
+    
+    #region Construction & Cloning
+    [StorableConstructor]
+    protected SPSOVelocityInitializer(bool deserializing) : base(deserializing) { }
+    protected SPSOVelocityInitializer(SPSOVelocityInitializer original, Cloner cloner) : base(original, cloner) { }
+    protected SPSOVelocityInitializer()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      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>("Velocity", "Particle's current velocity."));
+    }
+    #endregion
+  }
+}
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVector.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVector.cs	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVector.cs	(revision 15277)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -44,4 +45,5 @@
         array[i] = elements[i];
     }
+    public RealVector(RealVector other) : this(other.array) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -77,4 +79,11 @@
     }
 
+    public double DotProduct(RealVector other) {
+      if (other.Length != Length) throw new ArgumentException("Vectors are of unequal length.");
+      var dotProd = 0.0;
+      for (var i = 0; i < Length; i++)
+        dotProd += this[i] * other[i];
+      return dotProd;
+    }
   }
 }
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs	(revision 15258)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs	(revision 15277)
@@ -280,5 +280,4 @@
         particleCreator.RealVectorParameter.ActualName = Name;
         particleCreator.BoundsParameter.ActualName = BoundsParameter.Name;
-        particleCreator.ProblemSizeParameter.ActualName = LengthParameter.Name;
       }
     }
