Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/AdaptiveRandomTopologyUpdater.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/AdaptiveRandomTopologyUpdater.cs	(revision 15277)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/AdaptiveRandomTopologyUpdater.cs	(revision 15277)
@@ -0,0 +1,96 @@
+﻿#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.Collections.Generic;
+using System.Linq;
+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.Algorithms.ParticleSwarmOptimization {
+  [Item("SPSO Adaptive Random Topology Updater", "Each unsuccessful iteration the topology initializer is applied again.")]
+  [StorableClass]
+  public sealed class SPSOAdaptiveRandomTopologyUpdater : SingleSuccessorOperator, ITopologyUpdater, ISingleObjectiveOperator {
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    #region Parameters
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> SwarmBestQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["SwarmBestQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> PreviousBestQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["PreviousBestQuality"]; }
+    }
+    public ILookupParameter<ITopologyInitializer> TopologyInitializerParameter {
+      get { return (ILookupParameter<ITopologyInitializer>)Parameters["TopologyInitializer"]; }
+    }
+    public IScopeTreeLookupParameter<IntArray> NeighborsParameter {
+      get { return (IScopeTreeLookupParameter<IntArray>)Parameters["Neighbors"]; }
+    }
+    #endregion
+
+    #region Construction & Cloning
+    [StorableConstructor]
+    private SPSOAdaptiveRandomTopologyUpdater(bool deserializing) : base(deserializing) { }
+    private SPSOAdaptiveRandomTopologyUpdater(SPSOAdaptiveRandomTopologyUpdater original, Cloner cloner) : base(original, cloner) { }
+    public SPSOAdaptiveRandomTopologyUpdater()
+      : base() {
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "Whether the problem is to be maximized or not."));
+      Parameters.Add(new LookupParameter<DoubleValue>("SwarmBestQuality", "The swarm's best quality."));
+      Parameters.Add(new LookupParameter<DoubleValue>("PreviousBestQuality", "The best quality of the previous iteration."));
+      Parameters.Add(new LookupParameter<ITopologyInitializer>("TopologyInitializer", "The topology initializer is called again in case no improvement is made."));
+      Parameters.Add(new ScopeTreeLookupParameter<IntArray>("Neighbors", "The list of neighbors for each particle."));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SPSOAdaptiveRandomTopologyUpdater(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      var swarmBest = SwarmBestQualityParameter.ActualValue;
+      if (swarmBest == null) return base.Apply();
+
+      var previousBest = PreviousBestQualityParameter.ActualValue;
+      if (previousBest == null) {
+        PreviousBestQualityParameter.ActualValue = new DoubleValue(swarmBest.Value);
+        return base.Apply();
+      };
+
+      var successor = new OperationCollection(new[] { base.Apply() });
+      var max = MaximizationParameter.ActualValue.Value;
+      if (max && swarmBest.Value <= previousBest.Value
+        || !max && swarmBest.Value >= previousBest.Value)
+        successor.Insert(0, ExecutionContext.CreateOperation(TopologyInitializerParameter.ActualValue));
+
+      previousBest.Value = swarmBest.Value;
+      return successor;
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/HeuristicLab.Algorithms.ParticleSwarmOptimization-3.3.csproj
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/HeuristicLab.Algorithms.ParticleSwarmOptimization-3.3.csproj	(revision 15276)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/HeuristicLab.Algorithms.ParticleSwarmOptimization-3.3.csproj	(revision 15277)
@@ -113,7 +113,9 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AdaptiveRandomTopologyUpdater.cs" />
     <Compile Include="MultiPSOTopologyUpdater.cs" />
     <Compile Include="ParticleSwarmOptimizationMainLoop.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="SPSORandomTopologyInitializer.cs" />
     <Compile Include="RandomTopologyInitializer.cs" />
     <Compile Include="VonNeumannTopologyInitializer.cs" />
Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/MultiPSOTopologyUpdater.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/MultiPSOTopologyUpdater.cs	(revision 15276)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/MultiPSOTopologyUpdater.cs	(revision 15277)
@@ -33,5 +33,5 @@
   [Item("Multi PSO Topology Updater", "Splits swarm into NrOfSwarms non-overlapping sub-swarms. Swarms are re-grouped every regroupingPeriod iteration. The operator is implemented as described in Liang, J.J. and Suganthan, P.N 2005. Dynamic multi-swarm particle swarm optimizer. IEEE Swarm Intelligence Symposium, pp. 124-129.")]
   [StorableClass]
-  public sealed class MultiPSOTopologyUpdater : SingleSuccessorOperator, ITopologyUpdater {
+  public sealed class MultiPSOTopologyUpdater : SingleSuccessorOperator, ITopologyUpdater, IStochasticOperator {
 
     public override bool CanChangeName {
Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs	(revision 15276)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs	(revision 15277)
@@ -21,4 +21,5 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Analysis;
@@ -35,5 +36,5 @@
 
 namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
-  [Item("Particle Swarm Optimization (PSO)", "A particle swarm optimization algorithm based on the description in Pedersen, M.E.H. (2010). PhD thesis. University of Southampton.")]
+  [Item("Particle Swarm Optimization (PSO)", "A particle swarm optimization algorithm based on Standard PSO (SPSO) as described in Clerc, M. (2012). Standard particle swarm optimisation.")]
   [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 300)]
   [StorableClass]
@@ -176,10 +177,10 @@
       Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
       Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
-      Parameters.Add(new ValueParameter<IntValue>("SwarmSize", "Size of the particle swarm.", new IntValue(10)));
+      Parameters.Add(new ValueParameter<IntValue>("SwarmSize", "Size of the particle swarm.", new IntValue(40)));
       Parameters.Add(new ValueParameter<IntValue>("MaxIterations", "Maximal number of iterations.", new IntValue(1000)));
       Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
-      Parameters.Add(new ValueParameter<DoubleValue>("Inertia", "Inertia weight on a particle's movement (omega).", new DoubleValue(1)));
-      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>("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 ValueParameter<DoubleValue>("Inertia", "Inertia weight on a particle's movement (omega).", new DoubleValue(0.721)));
+      Parameters.Add(new ValueParameter<DoubleValue>("PersonalBestAttraction", "Weight for particle's pull towards its personal best soution (phi_p).", new DoubleValue(1.193)));
+      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(1.193)));
       Parameters.Add(new ConstrainedValueParameter<IParticleCreator>("ParticleCreator", "Operator that creates a new particle."));
       Parameters.Add(new ConstrainedValueParameter<IParticleUpdater>("ParticleUpdater", "Operator that updates a particle."));
@@ -188,5 +189,4 @@
       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"));
-      ParticleUpdaterParameter.Hidden = true;
 
       RandomCreator randomCreator = new RandomCreator();
@@ -262,4 +262,5 @@
       UpdateAnalyzers();
       ParameterizeAnalyzers();
+      UpdateParticleUpdaterParameter();
       UpdateTopologyParameters();
       InitializeParticleCreator();
@@ -280,13 +281,13 @@
 
     private void InitializeParticleCreator() {
+      ParticleCreatorParameter.ValidValues.Clear();
       if (Problem != null) {
         IParticleCreator oldParticleCreator = ParticleCreator;
         IParticleCreator defaultParticleCreator = Problem.Operators.OfType<IParticleCreator>().FirstOrDefault();
-        ParticleCreatorParameter.ValidValues.Clear();
-        foreach (IParticleCreator Creator in Problem.Operators.OfType<IParticleCreator>().OrderBy(x => x.Name)) {
-          ParticleCreatorParameter.ValidValues.Add(Creator);
+        foreach (var creator in Problem.Operators.OfType<IParticleCreator>().OrderBy(x => x.Name)) {
+          ParticleCreatorParameter.ValidValues.Add(creator);
         }
         if (oldParticleCreator != null) {
-          IParticleCreator creator = ParticleCreatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldParticleCreator.GetType());
+          var creator = ParticleCreatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldParticleCreator.GetType());
           if (creator != null) ParticleCreator = creator;
           else oldParticleCreator = null;
@@ -328,6 +329,6 @@
         updater.IndexParameter.ActualName = "Iterations";
         updater.ValueParameter.ActualName = "CurrentInertia";
-        updater.StartValueParameter.Value = new DoubleValue(1);
-        updater.EndValueParameter.Value = new DoubleValue(1E-10);
+        updater.StartValueParameter.ActualName = InertiaParameter.Name;
+        updater.EndValueParameter.Value = new DoubleValue(0.70);
       }
     }
@@ -346,9 +347,10 @@
 
     private void UpdateTopologyInitializer() {
-      ITopologyInitializer oldTopologyInitializer = TopologyInitializer;
+      var oldTopologyInitializer = TopologyInitializer;
       TopologyInitializerParameter.ValidValues.Clear();
       foreach (ITopologyInitializer topologyInitializer in ApplicationManager.Manager.GetInstances<ITopologyInitializer>().OrderBy(x => x.Name)) {
         TopologyInitializerParameter.ValidValues.Add(topologyInitializer);
       }
+
       if (oldTopologyInitializer != null && TopologyInitializerParameter.ValidValues.Any(x => x.GetType() == oldTopologyInitializer.GetType()))
         TopologyInitializer = TopologyInitializerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldTopologyInitializer.GetType());
@@ -357,35 +359,20 @@
 
     private void ParameterizeTopologyUpdaters() {
-      foreach (var updater in TopologyUpdaterParameter.ValidValues) {
-        var multiPsoUpdater = updater as MultiPSOTopologyUpdater;
-        if (multiPsoUpdater != null) {
-          multiPsoUpdater.CurrentIterationParameter.ActualName = "Iterations";
-        }
-      }
-    }
-
-    private void UpdateTopologyParameters() {
-      ITopologyUpdater oldTopologyUpdater = TopologyUpdater;
-      IParticleUpdater oldParticleUpdater = ParticleUpdater;
-      ClearTopologyParameters();
-      if (Problem != null) {
-        IParticleUpdater defaultParticleUpdater = null;
-        if (TopologyInitializer != null) {
-          foreach (ITopologyUpdater topologyUpdater in ApplicationManager.Manager.GetInstances<ITopologyUpdater>())
-            TopologyUpdaterParameter.ValidValues.Add(topologyUpdater);
-          defaultParticleUpdater = Problem.Operators.OfType<ILocalParticleUpdater>().FirstOrDefault();
-          foreach (IParticleUpdater particleUpdater in Problem.Operators.OfType<ILocalParticleUpdater>().OrderBy(x => x.Name))
-            ParticleUpdaterParameter.ValidValues.Add(particleUpdater);
-        } else {
-          defaultParticleUpdater = Problem.Operators.OfType<IGlobalParticleUpdater>().FirstOrDefault();
-          foreach (IParticleUpdater particleUpdater in Problem.Operators.OfType<IGlobalParticleUpdater>().OrderBy(x => x.Name))
-            ParticleUpdaterParameter.ValidValues.Add(particleUpdater);
-        }
-        if (oldTopologyUpdater != null) {
-          ITopologyUpdater newTopologyUpdater = TopologyUpdaterParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldParticleUpdater.GetType());
-          if (newTopologyUpdater != null) TopologyUpdater = newTopologyUpdater;
-        }
+      foreach (var updater in TopologyUpdaterParameter.ValidValues.OfType<MultiPSOTopologyUpdater>()) {
+        updater.CurrentIterationParameter.ActualName = "Iterations";
+      }
+    }
+
+    private void UpdateParticleUpdaterParameter() {
+      var oldParticleUpdater = ParticleUpdater;
+      ParticleUpdaterParameter.ValidValues.Clear();
+      if (Problem != null) {
+        var defaultParticleUpdater = Problem.Operators.OfType<IParticleUpdater>().FirstOrDefault();
+
+        foreach (var particleUpdater in Problem.Operators.OfType<IParticleUpdater>().OrderBy(x => x.Name))
+          ParticleUpdaterParameter.ValidValues.Add(particleUpdater);
+
         if (oldParticleUpdater != null) {
-          IParticleUpdater newParticleUpdater = ParticleUpdaterParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldParticleUpdater.GetType());
+          var newParticleUpdater = ParticleUpdaterParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldParticleUpdater.GetType());
           if (newParticleUpdater != null) ParticleUpdater = newParticleUpdater;
           else oldParticleUpdater = null;
@@ -393,12 +380,22 @@
         if (oldParticleUpdater == null && defaultParticleUpdater != null)
           ParticleUpdater = defaultParticleUpdater;
-
-        ParameterizeTopologyUpdaters();
-      }
-    }
-
-    private void ClearTopologyParameters() {
+      }
+    }
+
+    private void UpdateTopologyParameters() {
+      ITopologyUpdater oldTopologyUpdater = TopologyUpdater;
       TopologyUpdaterParameter.ValidValues.Clear();
-      ParticleUpdaterParameter.ValidValues.Clear();
+      if (Problem != null) {
+        if (TopologyInitializerParameter.Value != null) {
+          foreach (ITopologyUpdater topologyUpdater in ApplicationManager.Manager.GetInstances<ITopologyUpdater>())
+            TopologyUpdaterParameter.ValidValues.Add(topologyUpdater);
+
+          if (oldTopologyUpdater != null) {
+            ITopologyUpdater newTopologyUpdater = TopologyUpdaterParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldTopologyUpdater.GetType());
+            if (newTopologyUpdater != null) TopologyUpdater = newTopologyUpdater;
+          }
+          ParameterizeTopologyUpdaters();
+        }
+      }
     }
 
Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimizationMainLoop.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimizationMainLoop.cs	(revision 15276)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimizationMainLoop.cs	(revision 15277)
@@ -122,4 +122,5 @@
       Placeholder evaluatorPlaceholder = new Placeholder();
       Placeholder analyzerPlaceholder = new Placeholder();
+      Placeholder analyzer2Placeholder = new Placeholder();
       UniformSubScopesProcessor uniformSubScopeProcessor = new UniformSubScopesProcessor();
       Placeholder particleUpdaterPlaceholder = new Placeholder();
@@ -192,4 +193,8 @@
       conditionalBranch.ConditionParameter.ActualName = "ContinueIteration";
       conditionalBranch.TrueBranch = analyzerPlaceholder;
+      conditionalBranch.FalseBranch = analyzer2Placeholder;
+
+      analyzer2Placeholder.Name = "(Analyzer)";
+      analyzer2Placeholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
       #endregion
     }
Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RandomTopologyInitializer.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RandomTopologyInitializer.cs	(revision 15276)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RandomTopologyInitializer.cs	(revision 15277)
@@ -25,11 +25,12 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
-  [Item("Random Topology Initializer", "Randomly connectes every particle with k other particles.")]
+  [Item("Random Distinct Topology Initializer", "Each particle is informed by exactly k+1 distinct other particles (including itself).")]
   [StorableClass]
-  public sealed class RandomTopologyInitializer : TopologyInitializer {
+  public sealed class RandomTopologyInitializer : TopologyInitializer, IStochasticOperator {
     #region Parameters
     public ILookupParameter<IRandom> RandomParameter {
@@ -40,14 +41,5 @@
     }
     #endregion
-
-    #region Parameter Values
-    private IRandom Random {
-      get { return RandomParameter.ActualValue; }
-    }
-    private int NrOfConnections {
-      get { return NrOfConnectionsParameter.ActualValue.Value; }
-    }
-    #endregion
-
+    
     #region Construction & Cloning
     [StorableConstructor]
@@ -65,11 +57,16 @@
 
     public override IOperation Apply() {
-      ItemArray<IntArray> neighbors = new ItemArray<IntArray>(SwarmSize);
-      for (int i = 0; i < SwarmSize; i++) {
-        var numbers = Enumerable.Range(0, SwarmSize).ToList();
+      var random = RandomParameter.ActualValue;
+      var swarmSize = SwarmSizeParameter.ActualValue.Value;
+      var nrOfConnections = NrOfConnectionsParameter.ActualValue.Value;
+
+      ItemArray<IntArray> neighbors = new ItemArray<IntArray>(swarmSize);
+      for (int i = 0; i < swarmSize; i++) {
+        var numbers = Enumerable.Range(0, swarmSize).ToList();
         numbers.RemoveAt(i);
-        var selectedNumbers = new List<int>(NrOfConnections);
-        for (int j = 0; j < NrOfConnections && numbers.Count > 0; j++) {
-          int index = Random.Next(numbers.Count);
+        var selectedNumbers = new List<int>(nrOfConnections + 1);
+        selectedNumbers.Add(i);
+        for (int j = 0; j < nrOfConnections && numbers.Count > 0; j++) {
+          int index = random.Next(numbers.Count);
           selectedNumbers.Add(numbers[index]);
           numbers.RemoveAt(index);
@@ -77,5 +74,5 @@
         neighbors[i] = new IntArray(selectedNumbers.ToArray());
       }
-      Neighbors = neighbors;
+      NeighborsParameter.ActualValue = neighbors;
       return base.Apply();
     }
Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RingTopologyInitializer.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RingTopologyInitializer.cs	(revision 15276)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RingTopologyInitializer.cs	(revision 15277)
@@ -26,5 +26,5 @@
 
 namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
-  [Item("Ring Topology Initializer", "Connected every particle with its preceeding and its following particle.")]
+  [Item("Ring Topology Initializer", "Each particle is informed by its preceeding and its succeeding particle wrapping around at the beginning and the end of the swarm (in addition each particle also informs itself).")]
   [StorableClass]
   public sealed class RingTopologyInitializer : TopologyInitializer {
@@ -43,9 +43,11 @@
 
     public override IOperation Apply() {
-      ItemArray<IntArray> neighbors = new ItemArray<IntArray>(SwarmSize);
-      for (int i = 0; i < SwarmSize; i++) {
-        neighbors[i] = new IntArray(new[] { (SwarmSize + i - 1) % SwarmSize, (i + 1) % SwarmSize });
+      var swarmSize = SwarmSizeParameter.ActualValue.Value;
+
+      ItemArray<IntArray> neighbors = new ItemArray<IntArray>(swarmSize);
+      for (int i = 0; i < swarmSize; i++) {
+        neighbors[i] = new IntArray(new[] { (swarmSize + i - 1) % swarmSize, i, (i + 1) % swarmSize });
       }
-      Neighbors = neighbors;
+      NeighborsParameter.ActualValue = neighbors;
       return base.Apply();
     }
Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/SPSORandomTopologyInitializer.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/SPSORandomTopologyInitializer.cs	(revision 15277)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/SPSORandomTopologyInitializer.cs	(revision 15277)
@@ -0,0 +1,84 @@
+﻿#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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+  [Item("SPSO Random Topology Initializer", "Each particle informs k+1 other particles (including itself). The same particle (including itself) can be informed multiple times.")]
+  [StorableClass]
+  public sealed class SPSORandomTopologyInitializer : TopologyInitializer, IStochasticOperator {
+    #region Parameters
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IntValue> KParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["K"]; }
+    }
+    #endregion
+    
+    #region Construction & Cloning
+    [StorableConstructor]
+    private SPSORandomTopologyInitializer(bool deserializing) : base(deserializing) { }
+    private SPSORandomTopologyInitializer(SPSORandomTopologyInitializer original, Cloner cloner) : base(original, cloner) { }
+    public SPSORandomTopologyInitializer() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "A random number generation."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("K", "The number of informed particles (excluding itself).", new IntValue(3)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SPSORandomTopologyInitializer(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      var swarmSize = SwarmSizeParameter.ActualValue.Value;
+      var k = KParameter.ActualValue.Value;
+
+      // SPSO: Each particle informs at most K+1 particles (at least itself and K others)
+      //       it is by design that we draw from the particles with repetition
+      var particlesInform = new List<HashSet<int>>(swarmSize);
+      for (var i = 0; i < swarmSize; i++) {
+        var informs = new HashSet<int>() { i };
+        for (var j = 0; j < k; j++) {
+          informs.Add(random.Next(swarmSize));
+        }
+        particlesInform.Add(informs);
+      }
+
+      var neighbors = new ItemArray<IntArray>(swarmSize);
+      for (int i = 0; i < swarmSize; i++) {
+        // calculate the informants for each particle
+        var informants = particlesInform.Select((val, idx) => val.Contains(i) ? idx : -1).Where(x => x >= 0).ToArray();
+        neighbors[i] = new IntArray(informants);
+      }
+      NeighborsParameter.ActualValue = neighbors;
+      return base.Apply();
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/TopologyInitializer.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/TopologyInitializer.cs	(revision 15276)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/TopologyInitializer.cs	(revision 15277)
@@ -40,18 +40,6 @@
       get { return (IScopeTreeLookupParameter<IntArray>)Parameters["Neighbors"]; }
     }
-
     public ILookupParameter<IntValue> SwarmSizeParameter {
       get { return (ILookupParameter<IntValue>)Parameters["SwarmSize"]; }
-    }
-
-    #endregion
-
-    #region Parameter Values
-    protected ItemArray<IntArray> Neighbors {
-      get { return NeighborsParameter.ActualValue; }
-      set { NeighborsParameter.ActualValue = value; }
-    }
-    protected int SwarmSize {
-      get { return SwarmSizeParameter.ActualValue.Value; }
     }
     #endregion
Index: /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/VonNeumannTopologyInitializer.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/VonNeumannTopologyInitializer.cs	(revision 15276)
+++ /stable/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/VonNeumannTopologyInitializer.cs	(revision 15277)
@@ -26,5 +26,5 @@
 
 namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
-  [Item("Von Neumann Topology Initializer", "Every particle is connected with the two following and the two previous particles wrapping around at the beginning and the end of the population.")]
+  [Item("Von Neumann Topology Initializer", "Every particle is informed by the two following and the two previous particles wrapping around at the beginning and the end of the swarm (in addition each particle also informs itself).")]
   [StorableClass]
   public sealed class VonNeumannTopologyInitializer : TopologyInitializer {
@@ -44,14 +44,17 @@
 
     public override IOperation Apply() {
-      ItemArray<IntArray> neighbors = new ItemArray<IntArray>(SwarmSize);
-      for (int i = 0; i < SwarmSize; i++) {
+      var swarmSize = SwarmSizeParameter.ActualValue.Value;
+
+      ItemArray<IntArray> neighbors = new ItemArray<IntArray>(swarmSize);
+      for (int i = 0; i < swarmSize; i++) {
         neighbors[i] = new IntArray(new[] {
-          (SwarmSize + i-2) % SwarmSize,
-          (SwarmSize + i-1) % SwarmSize,
-          (i+1) % SwarmSize,
-          (i+2) % SwarmSize
+          (swarmSize + i-2) % swarmSize,
+          (swarmSize + i-1) % swarmSize,
+          i,
+          (i+1) % swarmSize,
+          (i+2) % swarmSize
         });
       }
-      Neighbors = neighbors;
+      NeighborsParameter.ActualValue = neighbors;
       return base.Apply();
     }
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 15276)
+++ /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 15276)
+++ /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 15276)
+++ /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 15276)
+++ /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 15276)
+++ /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 15276)
+++ /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 15276)
+++ /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 15276)
+++ /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 15276)
+++ /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 15276)
+++ /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;
       }
     }
Index: /stable/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj
===================================================================
--- /stable/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 15276)
+++ /stable/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 15277)
@@ -191,7 +191,5 @@
     <Compile Include="Interfaces\IDiscreteDoubleMatrixModifier.cs" />
     <Compile Include="Algorithms\HeuristicOptimizationEngineAlgorithm.cs" />
-    <Compile Include="Interfaces\IGlobalParticleUpdater.cs" />
     <Compile Include="Interfaces\ILocalImprovementOperator.cs" />
-    <Compile Include="Interfaces\ILocalParticleUpdater.cs" />
     <Compile Include="Algorithms\HeuristicOptimizationAlgorithm.cs" />
     <Compile Include="Interfaces\IMultiNeighborhoodShakingOperator.cs" />
Index: able/HeuristicLab.Optimization/3.3/Interfaces/IGlobalParticleUpdater.cs
===================================================================
--- /stable/HeuristicLab.Optimization/3.3/Interfaces/IGlobalParticleUpdater.cs	(revision 15276)
+++ 	(revision )
@@ -1,25 +1,0 @@
-﻿#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
-
-namespace HeuristicLab.Optimization {
-  public interface IGlobalParticleUpdater : IParticleUpdater {
-  }
-}
Index: able/HeuristicLab.Optimization/3.3/Interfaces/ILocalParticleUpdater.cs
===================================================================
--- /stable/HeuristicLab.Optimization/3.3/Interfaces/ILocalParticleUpdater.cs	(revision 15276)
+++ 	(revision )
@@ -1,25 +1,0 @@
-﻿#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
-
-namespace HeuristicLab.Optimization {
-  public interface ILocalParticleUpdater : IParticleUpdater {
-  }
-}
Index: /stable/HeuristicLab.Optimization/3.3/Interfaces/IParticleCreator.cs
===================================================================
--- /stable/HeuristicLab.Optimization/3.3/Interfaces/IParticleCreator.cs	(revision 15276)
+++ /stable/HeuristicLab.Optimization/3.3/Interfaces/IParticleCreator.cs	(revision 15277)
@@ -27,4 +27,5 @@
   /// </summary>
   public interface IParticleCreator : ISolutionCreator {
+    ILookupParameter<ISolutionCreator> SolutionCreatorParameter { get; }
   }
 }
Index: /stable/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj
===================================================================
--- /stable/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj	(revision 15276)
+++ /stable/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj	(revision 15277)
@@ -129,5 +129,4 @@
     <EmbeddedResource Include="Documents\SGP_SymbReg.hl" />
     <EmbeddedResource Include="Documents\VNS_TSP.hl" />
-    <EmbeddedResource Include="Documents\PSO_Schwefel.hl" />
     <EmbeddedResource Include="Documents\SS_VRP.hl" />
     <EmbeddedResource Include="Documents\RAPGA_JSSP.hl" />
@@ -153,4 +152,5 @@
     <EmbeddedResource Include="Documents\SGP_Robocode.hl" />
     <EmbeddedResource Include="Documents\OSGP_SymReg.hl" />
+    <EmbeddedResource Include="Documents\PSO_Rastrigin.hl" />
     <None Include="Plugin.cs.frame" />
     <Compile Include="ChangeNestingLevelDialog.cs">
Index: /stable/HeuristicLab.Optimizer/3.3/StartPage.cs
===================================================================
--- /stable/HeuristicLab.Optimizer/3.3/StartPage.cs	(revision 15276)
+++ /stable/HeuristicLab.Optimizer/3.3/StartPage.cs	(revision 15277)
@@ -134,5 +134,5 @@
     private void FillGroupLookup() {
       var standardProblems = new List<string> { "ALPSGA_TSP", "ES_Griewank", "OSES_Griewank", "GA_Grouping", "GA_TSP", "GA_VRP", "GE_ArtificialAnt",
-                "IslandGA_TSP", "LS_Knapsack", "PSO_Schwefel", "RAPGA_JSSP",
+                "IslandGA_TSP", "LS_Knapsack", "PSO_Rastrigin", "RAPGA_JSSP",
                 "SA_Rastrigin", "SGP_SantaFe", "GP_Multiplexer", "SGP_Robocode", "SS_VRP", "TS_TSP", "TS_VRP", "VNS_OP", "VNS_TSP", "GA_BPP"
         };
Index: /stable/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs
===================================================================
--- /stable/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 15276)
+++ /stable/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 15277)
@@ -359,6 +359,4 @@
         op.BoundsParameter.ActualName = BoundsParameter.Name;
         op.BoundsParameter.Hidden = true;
-        op.ProblemSizeParameter.ActualName = ProblemSizeParameter.Name;
-        op.ProblemSizeParameter.Hidden = true;
       }
       foreach (var op in Operators.OfType<IRealVectorParticleUpdater>()) {
Index: /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/PsoRastriginSampleTest.cs
===================================================================
--- /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/PsoRastriginSampleTest.cs	(revision 15277)
+++ /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/PsoRastriginSampleTest.cs	(revision 15277)
@@ -0,0 +1,91 @@
+﻿#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.IO;
+using System.Linq;
+using HeuristicLab.Algorithms.ParticleSwarmOptimization;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.Xml;
+using HeuristicLab.Problems.TestFunctions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace HeuristicLab.Tests {
+  [TestClass]
+  public class PsoRastriginSampleTest {
+    private const string SampleFileName = "PSO_Rastrigin";
+
+    [TestMethod]
+    [TestCategory("Samples.Create")]
+    [TestProperty("Time", "medium")]
+    public void CreatePsoRastriginSampleTest() {
+      var pso = CreatePsoRastriginSample();
+      string path = Path.Combine(SamplesUtils.SamplesDirectory, SampleFileName + SamplesUtils.SampleFileExtension);
+      XmlGenerator.Serialize(pso, path);
+    }
+    [TestMethod]
+    [TestCategory("Samples.Execute")]
+    [TestProperty("Time", "medium")]
+    public void RunPsoRastriginSampleTest() {
+      var pso = CreatePsoRastriginSample();
+      pso.SetSeedRandomly.Value = false;
+      SamplesUtils.RunAlgorithm(pso);
+      if (Environment.Is64BitProcess) {
+        Assert.AreEqual(0, SamplesUtils.GetDoubleResult(pso, "BestQuality"));
+        Assert.AreEqual(3.9649516110677525, SamplesUtils.GetDoubleResult(pso, "CurrentAverageQuality"), 1e-08);
+        Assert.AreEqual(25.566430359483757, SamplesUtils.GetDoubleResult(pso, "CurrentWorstQuality"), 1e-08);
+        Assert.AreEqual(200, SamplesUtils.GetIntResult(pso, "Iterations"));
+      } else {
+        Assert.AreEqual(0, SamplesUtils.GetDoubleResult(pso, "BestQuality"));
+        Assert.AreEqual(3.3957460831564048, SamplesUtils.GetDoubleResult(pso, "CurrentAverageQuality"), 1e-08);
+        Assert.AreEqual(34.412788077766145, SamplesUtils.GetDoubleResult(pso, "CurrentWorstQuality"), 1e-08);
+        Assert.AreEqual(200, SamplesUtils.GetIntResult(pso, "Iterations"));
+      }
+    }
+
+    private ParticleSwarmOptimization CreatePsoRastriginSample() {
+      ParticleSwarmOptimization pso = new ParticleSwarmOptimization();
+      #region Problem Configuration
+      var problem = new SingleObjectiveTestFunctionProblem();
+      var provider = new SOTFInstanceProvider();
+      problem.Load(provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name == "Rastrigin Function")));
+      problem.SolutionCreatorParameter.Value = new UniformRandomRealVectorCreator();
+      #endregion
+      #region Algorithm Configuration
+      pso.Name = "Particle Swarm Optimization - Rastrigin";
+      pso.Description = "A particle swarm optimization algorithm which solves the 2-dimensional Rastrigin test function.";
+      pso.Problem = problem;
+      pso.Inertia.Value = 0.721;
+      pso.MaxIterations.Value = 200;
+      pso.NeighborBestAttraction.Value = 1.193;
+      pso.PersonalBestAttraction.Value = 1.193;
+      pso.SwarmSize.Value = 40;
+            
+      pso.TopologyInitializer = pso.TopologyInitializerParameter.ValidValues.OfType<SPSORandomTopologyInitializer>().First();
+      pso.TopologyUpdater = pso.TopologyUpdaterParameter.ValidValues.OfType<SPSOAdaptiveRandomTopologyUpdater>().First();
+      pso.Seed.Value = 0;
+      pso.SetSeedRandomly.Value = true;
+      #endregion
+      pso.Engine = new ParallelEngine.ParallelEngine();
+      return pso;
+    }
+  }
+}
Index: able/HeuristicLab.Tests/HeuristicLab-3.3/Samples/PsoSchwefelSampleTest.cs
===================================================================
--- /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/PsoSchwefelSampleTest.cs	(revision 15276)
+++ 	(revision )
@@ -1,119 +1,0 @@
-﻿#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.IO;
-using System.Linq;
-using HeuristicLab.Algorithms.ParticleSwarmOptimization;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Optimization.Operators;
-using HeuristicLab.Persistence.Default.Xml;
-using HeuristicLab.Problems.TestFunctions;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace HeuristicLab.Tests {
-  [TestClass]
-  public class PsoSchwefelSampleTest {
-    private const string SampleFileName = "PSO_Schwefel";
-
-    [TestMethod]
-    [TestCategory("Samples.Create")]
-    [TestProperty("Time", "medium")]
-    public void CreatePsoSchwefelSampleTest() {
-      var pso = CreatePsoSchwefelSample();
-      string path = Path.Combine(SamplesUtils.SamplesDirectory, SampleFileName + SamplesUtils.SampleFileExtension);
-      XmlGenerator.Serialize(pso, path);
-    }
-    [TestMethod]
-    [TestCategory("Samples.Execute")]
-    [TestProperty("Time", "medium")]
-    public void RunPsoSchwefelSampleTest() {
-      var pso = CreatePsoSchwefelSample();
-      pso.SetSeedRandomly.Value = false;
-      SamplesUtils.RunAlgorithm(pso);
-      if (!Environment.Is64BitProcess) {
-        Assert.AreEqual(118.44027985932837, SamplesUtils.GetDoubleResult(pso, "BestQuality"));
-        Assert.AreEqual(140.71570105946438, SamplesUtils.GetDoubleResult(pso, "CurrentAverageQuality"));
-        Assert.AreEqual(220.956806502853, SamplesUtils.GetDoubleResult(pso, "CurrentWorstQuality"));
-        Assert.AreEqual(1000, SamplesUtils.GetIntResult(pso, "Iterations"));
-      } else {
-        Assert.AreEqual(118.43958282879345, SamplesUtils.GetDoubleResult(pso, "BestQuality"));
-        Assert.AreEqual(139.43946864779372, SamplesUtils.GetDoubleResult(pso, "CurrentAverageQuality"));
-        Assert.AreEqual(217.14654589055152, SamplesUtils.GetDoubleResult(pso, "CurrentWorstQuality"));
-        Assert.AreEqual(1000, SamplesUtils.GetIntResult(pso, "Iterations"));
-      }
-    }
-
-    private ParticleSwarmOptimization CreatePsoSchwefelSample() {
-      ParticleSwarmOptimization pso = new ParticleSwarmOptimization();
-      #region Problem Configuration
-      var problem = new SingleObjectiveTestFunctionProblem();
-      problem.BestKnownQuality.Value = 0.0;
-      problem.BestKnownSolutionParameter.Value = new RealVector(new double[] { 420.968746, 420.968746 });
-      problem.Bounds = new DoubleMatrix(new double[,] { { -500, 500 } });
-      problem.EvaluatorParameter.Value = new SchwefelEvaluator();
-      problem.Maximization.Value = false;
-      problem.ProblemSize.Value = 2;
-      problem.SolutionCreatorParameter.Value = new UniformRandomRealVectorCreator();
-      #endregion
-      #region Algorithm Configuration
-      pso.Name = "Particle Swarm Optimization - Schwefel";
-      pso.Description = "A particle swarm optimization algorithm which solves the 2-dimensional Schwefel test function (based on the description in Pedersen, M.E.H. (2010). PhD thesis. University of Southampton)";
-      pso.Problem = problem;
-      pso.Inertia.Value = 10;
-      pso.MaxIterations.Value = 1000;
-      pso.NeighborBestAttraction.Value = 0.5;
-      pso.PersonalBestAttraction.Value = -0.01;
-      pso.SwarmSize.Value = 50;
-
-      var inertiaUpdater = pso.InertiaUpdaterParameter.ValidValues
-        .OfType<ExponentialDiscreteDoubleValueModifier>()
-        .Single();
-      inertiaUpdater.StartValueParameter.Value = new DoubleValue(10);
-      inertiaUpdater.EndValueParameter.Value = new DoubleValue(1);
-      pso.InertiaUpdater = inertiaUpdater;
-
-      pso.ParticleCreator = pso.ParticleCreatorParameter.ValidValues
-        .OfType<RealVectorParticleCreator>()
-        .Single();
-      var swarmUpdater = pso.SwarmUpdaterParameter.ValidValues
-        .OfType<RealVectorSwarmUpdater>()
-        .Single();
-      swarmUpdater.VelocityBoundsIndexParameter.ActualName = "Iterations";
-      swarmUpdater.VelocityBoundsParameter.Value = new DoubleMatrix(new double[,] { { -10, 10 } });
-      swarmUpdater.VelocityBoundsStartValueParameter.Value = new DoubleValue(10.0);
-      swarmUpdater.VelocityBoundsEndValueParameter.Value = new DoubleValue(1.0);
-      swarmUpdater.VelocityBoundsScalingOperatorParameter.Value = swarmUpdater.VelocityBoundsScalingOperatorParameter.ValidValues
-        .OfType<ExponentialDiscreteDoubleValueModifier>()
-        .Single();
-
-      pso.TopologyInitializer = null;
-      pso.TopologyUpdater = null;
-      pso.SwarmUpdater = swarmUpdater;
-      pso.Seed.Value = 0;
-      pso.SetSeedRandomly.Value = true;
-      #endregion
-      pso.Engine = new ParallelEngine.ParallelEngine();
-      return pso;
-    }
-  }
-}
Index: /stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- /stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15276)
+++ /stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15277)
@@ -475,5 +475,5 @@
     <Compile Include="HeuristicLab-3.3\Samples\GPMultiplexerSampleTest.cs" />
     <Compile Include="HeuristicLab-3.3\Samples\LocalSearchKnapsackSampleTest.cs" />
-    <Compile Include="HeuristicLab-3.3\Samples\PsoSchwefelSampleTest.cs" />
+    <Compile Include="HeuristicLab-3.3\Samples\PsoRastriginSampleTest.cs" />
     <Compile Include="HeuristicLab-3.3\Samples\RAPGASchedulingSampleTest.cs" />
     <Compile Include="HeuristicLab-3.3\Samples\SamplesUtils.cs" />
