Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/EmptyTopologyInitializer.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/EmptyTopologyInitializer.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/EmptyTopologyInitializer.cs	(revision 5209)
@@ -0,0 +1,47 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Algorithms.ParticleSwarmOptimization {
+
+  [StorableClass]
+  public class EmptyTopologyInitializer : TopologyInitializer {
+
+    #region Construction & Cloning
+    public EmptyTopologyInitializer() { }
+    [StorableConstructor]
+    protected EmptyTopologyInitializer(bool deserializing) : base(deserializing) { }
+    protected EmptyTopologyInitializer(EmptyTopologyInitializer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptyTopologyInitializer(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      return base.Apply();
+    }
+
+  }
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/HeuristicLab.Algorithms.ParticleSwarmOptimization-3.3.csproj
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/HeuristicLab.Algorithms.ParticleSwarmOptimization-3.3.csproj	(revision 5208)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/HeuristicLab.Algorithms.ParticleSwarmOptimization-3.3.csproj	(revision 5209)
@@ -11,5 +11,5 @@
     <RootNamespace>HeuristicLab.Algorithms.ParticleSwarmOptimization</RootNamespace>
     <AssemblyName>HeuristicLab.Algorithms.ParticleSwarmOptimization-3.3</AssemblyName>
-    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <SignAssembly>true</SignAssembly>
@@ -34,4 +34,5 @@
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
@@ -91,4 +92,7 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3">
+      <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core">
@@ -106,4 +110,16 @@
   <ItemGroup>
     <Compile Include="BestPointInitializer.cs" />
+    <Compile Include="RandomTopologyInitializer.cs" />
+    <Compile Include="VonNeumannTopologyInitializer.cs" />
+    <Compile Include="EmptyTopologyInitializer.cs" />
+    <Compile Include="RingTopologyInitializer.cs" />
+    <Compile Include="ITopologyUpdater.cs" />
+    <Compile Include="IdentityTopologyUpdater.cs" />
+    <Compile Include="NeighborUpdater.cs" />
+    <Compile Include="TopologyInitializer.cs" />
+    <Compile Include="ITopologyInitializer.cs" />
+    <Compile Include="NeighborhoodParticleUpdater.cs" />
+    <Compile Include="IParticleUpdater.cs" />
+    <Compile Include="TotallyConnectedParticleUpdater.cs" />
     <Compile Include="HeuristicLabAlgorithmsParticleSwarmOptimizationPlugin.cs" />
     <Compile Include="ParticleSwarmOptimization.cs" />
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/IParticleUpdater.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/IParticleUpdater.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/IParticleUpdater.cs	(revision 5209)
@@ -0,0 +1,45 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  public interface IParticleUpdater : IItem {
+    LookupParameter<RealVector> VelocityParameter { get; }
+    LookupParameter<DoubleMatrix> VelocityBoundsParameter { get; }
+
+    LookupParameter<RealVector> PointParameter { get; }
+    LookupParameter<DoubleMatrix> BoundsParameter { get; }
+
+    LookupParameter<RealVector> PersonalBestPointParameter { get; }
+    LookupParameter<RealVector> BestNeighborPointParameter { get; }
+    LookupParameter<RealVector> BestPointParameter { get; }
+
+    LookupParameter<DoubleValue> OmegaParameter { get; }
+    LookupParameter<DoubleValue> Phi_PParameter { get; }
+    LookupParameter<DoubleValue> Phi_GParameter { get; }
+  }
+
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ITopologyInitializer.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ITopologyInitializer.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ITopologyInitializer.cs	(revision 5209)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Parameters;
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  public interface ITopologyInitializer : IItem {
+    ScopeTreeLookupParameter<IntegerVector> NeighborsParameter { get; }
+    LookupParameter<IntValue> SwarmSizeParameter { get; }
+  }
+
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ITopologyUpdater.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ITopologyUpdater.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ITopologyUpdater.cs	(revision 5209)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Parameters;
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  public interface ITopologyUpdater : IItem {
+    ScopeTreeLookupParameter<IntegerVector> NeighborsParameter { get; }
+  }
+
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/IdentityTopologyUpdater.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/IdentityTopologyUpdater.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/IdentityTopologyUpdater.cs	(revision 5209)
@@ -0,0 +1,49 @@
+﻿using HeuristicLab.Common;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  [StorableClass]
+  public class IdentityTopologyUpdater : SingleSuccessorOperator, ITopologyUpdater {
+
+    public ScopeTreeLookupParameter<IntegerVector> NeighborsParameter {
+      get { return (ScopeTreeLookupParameter<IntegerVector>)Parameters["Neighbors"]; }
+    }
+
+    public IdentityTopologyUpdater() {
+      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("Neighbors", "The list of neighbors for each particle."));
+    }
+    [StorableConstructor]
+    protected IdentityTopologyUpdater(bool deserializing) : base(deserializing) { }
+    protected IdentityTopologyUpdater(IdentityTopologyUpdater original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IdentityTopologyUpdater(this, cloner);
+    }
+  }
+
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/NeighborUpdater.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/NeighborUpdater.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/NeighborUpdater.cs	(revision 5209)
@@ -0,0 +1,106 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  public class NeighborUpdater : SingleSuccessorOperator {
+
+    #region Parameters
+    public ScopeTreeLookupParameter<RealVector> PointsParameter {
+      get { return (ScopeTreeLookupParameter<RealVector>)Parameters["Point"]; }
+    }
+    public ScopeTreeLookupParameter<IntegerVector> NeighborsParameter {
+      get { return (ScopeTreeLookupParameter<IntegerVector>)Parameters["Neighbors"]; }
+    }
+    public ScopeTreeLookupParameter<RealVector> BestNeighborPointParameter {
+      get { return (ScopeTreeLookupParameter<RealVector>)Parameters["BestNeighborPoint"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public LookupParameter<BoolValue> MaximizationParameter {
+      get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    #endregion
+
+    #region Parameter Values
+    public ItemArray<RealVector> Points {
+      get { return PointsParameter.ActualValue; }
+    }
+    public ItemArray<IntegerVector> Neighbors {
+      get { return NeighborsParameter.ActualValue; }
+    }
+    public ItemArray<RealVector> BestNeighborPoints {
+      get { return BestNeighborPointParameter.ActualValue; }
+      set { BestNeighborPointParameter.ActualValue = value; }
+    }
+    public ItemArray<DoubleValue> Qualities {
+      get { return QualityParameter.ActualValue; }
+    }
+    public bool Maximization {
+      get { return MaximizationParameter.ActualValue.Value; }
+    }
+    #endregion
+
+    #region Construction & Cloning
+    public NeighborUpdater() {
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("Point", "The position of the particle."));
+      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("Neighbors", "The list of neighbors for each particle."));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("BestNeighborPoint", "The position of the best neighboring particle."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The list of qualities of all particles."));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem."));
+    }
+    [StorableConstructor]
+    protected NeighborUpdater(bool deserializing) : base(deserializing) { }
+    protected NeighborUpdater(NeighborUpdater original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NeighborUpdater(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      if (Neighbors != null & Neighbors.Length > 0) {
+        if (BestNeighborPoints == null || BestNeighborPoints.Length != Neighbors.Length)
+          BestNeighborPoints = new ItemArray<RealVector>(Neighbors.Length);
+        for (int n = 0; n<Neighbors.Length; n++) {
+          var pairs = Qualities.Zip(Points, (q, p) => new { Quality = q, Point = p })
+            .Where((p, i) => i == n || Neighbors[n].Contains(i));
+          BestNeighborPoints[n] = Maximization ? 
+          pairs.OrderByDescending(p => p.Quality.Value).First().Point :
+          pairs.OrderBy(p => p.Quality.Value).First().Point;
+        }
+        BestNeighborPointParameter.ActualValue = BestNeighborPoints;
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/NeighborhoodParticleUpdater.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/NeighborhoodParticleUpdater.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/NeighborhoodParticleUpdater.cs	(revision 5209)
@@ -0,0 +1,67 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  [StorableClass]
+  public class NeighborhoodParticleUpdater : ParticleUpdater {
+
+    #region Construction & Cloning
+
+    [StorableConstructor]
+    protected NeighborhoodParticleUpdater(bool deserializing) : base(deserializing) { }
+    protected NeighborhoodParticleUpdater(ParticleUpdater original, Cloner cloner) : base(original, cloner) { }
+    public NeighborhoodParticleUpdater() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NeighborhoodParticleUpdater(this, cloner);
+    }
+
+    #endregion
+
+    public override IOperation Apply() {
+      RealVector velocity = new RealVector(Velocity.Length);
+      RealVector position = new RealVector(Point.Length);
+      double r_p = Random.NextDouble();
+      double r_g = Random.NextDouble();
+      for (int i = 0; i < velocity.Length; i++) {
+        velocity[i] =
+          Velocity[i] * Omega +
+          (PersonalBestPoint[i] - Point[i]) * Phi_P * r_p +
+          (BestNeighborPoint[i] - Point[i]) * Phi_G * r_g;
+      }
+      BoundsChecker.Apply(velocity, VelocityBounds);
+      for (int i = 0; i < velocity.Length; i++) {
+        position[i] = Point[i] + velocity[i];
+      }
+      BoundsChecker.Apply(position, Bounds);
+      Point = position;
+      Velocity = velocity;
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs	(revision 5208)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs	(revision 5209)
@@ -32,9 +32,10 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Random;
 
 namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
 
-  [Item("Particle Swarm Optimization", "A particle swarm optimization algorithm.")]
+  [Item("Particle Swarm Optimization", "A particle swarm optimization algorithm based on the description in Pedersen, M.E.H. (2010). PhD thesis. University of Southampton.")]
   [Creatable("Algorithms")]
   [StorableClass]
@@ -82,4 +83,13 @@
     public ValueLookupParameter<DoubleMatrix> VelocityBoundsParameter {
       get { return (ValueLookupParameter<DoubleMatrix>)Parameters["VelocityBounds"]; }
+    }
+    public ConstrainedValueParameter<IParticleUpdater> ParticleUpdaterParameter {
+      get { return (ConstrainedValueParameter<IParticleUpdater>)Parameters["ParticleUpdater"]; }
+    }
+    public ConstrainedValueParameter<ITopologyInitializer> TopologyInitializerParameter {
+      get { return (ConstrainedValueParameter<ITopologyInitializer>)Parameters["TopologyInitializer"]; }
+    }
+    public ConstrainedValueParameter<ITopologyUpdater> TopologyUpdaterParameter {
+      get { return (ConstrainedValueParameter<ITopologyUpdater>)Parameters["TopologyUpdater"]; }
     }
     #endregion
@@ -108,4 +118,13 @@
       Parameters.Add(new ValueParameter<DoubleValue>("Phi_G", "Weight for global best position.", new DoubleValue(3.7)));
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("VelocityBounds", "Maximum Velocity in every dimension", new DoubleMatrix(new double[,] { { -1, 1 } })));
+      Parameters.Add(new ConstrainedValueParameter<IParticleUpdater>("ParticleUpdater", "Operator that calculates new position and velocity of a particle",
+        new ItemSet<IParticleUpdater>(ApplicationManager.Manager.GetInstances<IParticleUpdater>())));
+      Parameters.Add(new ConstrainedValueParameter<ITopologyInitializer>("TopologyInitializer", "Creates neighborhood description vectors",
+        new ItemSet<ITopologyInitializer>(ApplicationManager.Manager.GetInstances<ITopologyInitializer>())));
+      Parameters.Add(new ConstrainedValueParameter<ITopologyUpdater>("TopologyUpdater", "Updates the neighborhood description vectors",
+        new ItemSet<ITopologyUpdater>(ApplicationManager.Manager.GetInstances<ITopologyUpdater>())));
+      ParticleUpdaterParameter.ActualValue = ParticleUpdaterParameter.ValidValues.SingleOrDefault(v => v.GetType() == typeof(TotallyConnectedParticleUpdater));
+      TopologyInitializerParameter.ActualValue = TopologyInitializerParameter.ValidValues.SingleOrDefault(v => v.GetType() == typeof(EmptyTopologyInitializer));
+      TopologyUpdaterParameter.ActualValue = TopologyUpdaterParameter.ValidValues.SingleOrDefault(v => v.GetType() == typeof(IdentityTopologyUpdater));
 
       RandomCreator randomCreator = new RandomCreator();
@@ -116,7 +135,12 @@
       Assigner bestPersonalQualityAssigner = new Assigner();
       BestPointInitializer bestPositionInitializer = new BestPointInitializer();
+      Placeholder topologyInitializerPlaceholder = new Placeholder();
+      NeighborUpdater neighborUpdater = new NeighborUpdater();
       Placeholder analyzerPlaceholder = new Placeholder();
       UniformSubScopesProcessor uniformSubScopeProcessor = new UniformSubScopesProcessor();
-      ParticleUpdater particleUpdater = new ParticleUpdater();
+      Placeholder particleUpdaterPlaceholder = new Placeholder();
+      Placeholder topologyUpdaterPlaceholder = new Placeholder();
+      UniformSubScopesProcessor uniformSubscopesProcessor2 = new UniformSubScopesProcessor();
+      NeighborUpdater neighborUpdater2 = new NeighborUpdater();
       Placeholder evaluatorPlaceholder2 = new Placeholder();
       SwarmUpdater swarmUpdater = new SwarmUpdater();
@@ -149,5 +173,11 @@
       bestPersonalQualityAssigner.RightSideParameter.ActualName = "Quality";
 
-      bestPositionInitializer.Successor = analyzerPlaceholder;
+      bestPositionInitializer.Successor = topologyInitializerPlaceholder;
+
+      topologyInitializerPlaceholder.Name = "(TopologyInitializer)";
+      topologyInitializerPlaceholder.OperatorParameter.ActualName = "TopologyInitializer";
+      topologyInitializerPlaceholder.Successor = neighborUpdater;
+
+      neighborUpdater.Successor = analyzerPlaceholder;
 
       analyzerPlaceholder.Name = "(Analyzer)";
@@ -155,12 +185,22 @@
       analyzerPlaceholder.Successor = uniformSubScopeProcessor;
 
-      uniformSubScopeProcessor.Operator = particleUpdater;
-      uniformSubScopeProcessor.Successor = analyzerPlaceholder2;
-
-      particleUpdater.Successor = evaluatorPlaceholder2;
+      uniformSubScopeProcessor.Operator = particleUpdaterPlaceholder;
+      uniformSubScopeProcessor.Successor = topologyUpdaterPlaceholder;
+
+      particleUpdaterPlaceholder.Name = "(ParticleUpdater)";
+      particleUpdaterPlaceholder.OperatorParameter.ActualName = "ParticleUpdater";
+      particleUpdaterPlaceholder.Successor = evaluatorPlaceholder2;
 
       evaluatorPlaceholder2.Name = "(Evaluator)";
       evaluatorPlaceholder2.OperatorParameter.ActualName = "Evaluator";
-      evaluatorPlaceholder2.Successor = swarmUpdater;
+
+      topologyUpdaterPlaceholder.Name = "(TopologyUpdater)";
+      topologyUpdaterPlaceholder.OperatorParameter.ActualName = "TopologyUpdater";
+      topologyUpdaterPlaceholder.Successor = neighborUpdater2;
+
+      neighborUpdater2.Successor = uniformSubscopesProcessor2;
+
+      uniformSubscopesProcessor2.Operator = swarmUpdater;
+      uniformSubscopesProcessor2.Successor = analyzerPlaceholder2;
 
       analyzerPlaceholder2.Name = "(Analyzer)";
@@ -226,4 +266,7 @@
 
     #region Helpers
+    private void InitializeParticleUpdaters() {
+    }
+
     private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
     }
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleUpdater.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleUpdater.cs	(revision 5208)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleUpdater.cs	(revision 5209)
@@ -31,5 +31,5 @@
 
   [StorableClass]
-  public class ParticleUpdater : SingleSuccessorOperator {
+  public abstract class ParticleUpdater : SingleSuccessorOperator, IParticleUpdater {
 
     #region Parameter properties
@@ -45,4 +45,7 @@
     public LookupParameter<RealVector> PersonalBestPointParameter {
       get { return (LookupParameter<RealVector>)Parameters["PersonalBestPoint"]; }
+    }
+    public LookupParameter<RealVector> BestNeighborPointParameter {
+      get { return (LookupParameter<RealVector>)Parameters["BestNeighborPoint"]; }
     }
     public LookupParameter<RealVector> BestPointParameter {
@@ -84,4 +87,7 @@
       get { return BestPointParameter.ActualValue; }
     }
+    public RealVector BestNeighborPoint {
+      get { return BestNeighborPointParameter.ActualValue; }
+    }
     public DoubleMatrix Bounds {
       get { return BoundsParameter.ActualValue; }
@@ -101,4 +107,8 @@
     #endregion
 
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
     #region Construction & Cloning
 
@@ -116,4 +126,5 @@
       Parameters.Add(new LookupParameter<RealVector>("PersonalBestPoint", "Particle's personal best position"));
       Parameters.Add(new LookupParameter<RealVector>("BestPoint", "Global best position"));
+      Parameters.Add(new LookupParameter<RealVector>("BestNeighborPoint", "Best neighboring position"));
       Parameters.Add(new LookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds for each dimension of the position vector for the current problem."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("VelocityBounds", "Upper and lower bounds for the particle's velocity vector."));
@@ -123,35 +134,6 @@
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ParticleUpdater(this, cloner);
-    }
-
     #endregion
 
-    public override IOperation Apply() {
-      RealVector velocity = new RealVector(Velocity.Length);
-      RealVector position = new RealVector(Point.Length);
-      double r_p = Random.NextDouble();
-      double r_g = Random.NextDouble();
-      for (int i = 0; i < velocity.Length; i++) {
-        velocity[i] =
-          Velocity[i] * Omega +
-          (PersonalBestPoint[i] - Point[i]) * Phi_P * r_p +
-          (BestPoint[i] - Point[i]) * Phi_G * r_g;
-      }
-      BoundsChecker.Apply(velocity, VelocityBounds);
-      for (int i = 0; i < velocity.Length; i++) {
-        position[i] = Point[i] + velocity[i];
-      }
-      BoundsChecker.Apply(position, Bounds);
-      Point = position;
-      Velocity = velocity;
-
-      return base.Apply();
-    }
-
-    public override bool CanChangeName {
-      get { return false; }
-    }
   }
 }
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RandomTopologyInitializer.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RandomTopologyInitializer.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RandomTopologyInitializer.cs	(revision 5209)
@@ -0,0 +1,85 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  public class RandomTopologyInitializer : TopologyInitializer {
+
+    #region Parameters
+    public LookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ValueLookupParameter<IntValue> NrOfConnectionsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["NrOfConnections"]; }
+    }
+    #endregion
+
+    #region Parameter Values
+    public IRandom Random {
+      get { return RandomParameter.ActualValue; }
+    }
+    public int NrOfConnections {
+      get { return NrOfConnectionsParameter.ActualValue.Value; }
+    }
+    #endregion
+
+    #region Construction & Cloning
+    public RandomTopologyInitializer() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "A random number generation."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NrOfConnections", "Nr of connected neighbors.", new IntValue(3)));
+    }
+    [StorableConstructor]
+    protected RandomTopologyInitializer(bool deserializing) : base(deserializing) { }
+    protected RandomTopologyInitializer(RandomTopologyInitializer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RandomTopologyInitializer(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      ItemArray<IntegerVector> neighbors = new ItemArray<IntegerVector>(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);
+          selectedNumbers.Add(numbers[index]);
+          numbers.RemoveAt(index);
+        }
+        neighbors[i] = new IntegerVector(selectedNumbers.ToArray());
+      }
+      Neighbors = neighbors;
+      return base.Apply();
+    }
+
+  }
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RingTopologyInitializer.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RingTopologyInitializer.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/RingTopologyInitializer.cs	(revision 5209)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  public class RingTopologyInitializer : TopologyInitializer {
+
+    #region Construction & Cloning
+    public RingTopologyInitializer() { }
+    [StorableConstructor]
+    protected RingTopologyInitializer(bool deserializing) : base(deserializing) { }
+    protected RingTopologyInitializer(RingTopologyInitializer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RingTopologyInitializer(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      ItemArray<IntegerVector> neighbors = new ItemArray<IntegerVector>(SwarmSize);
+      for (int i = 0; i<SwarmSize; i++) {
+        neighbors[i] = new IntegerVector(new[] { (SwarmSize + i-1) % SwarmSize, (i+1) % SwarmSize });
+      }
+      Neighbors = neighbors;
+      return base.Apply();
+    }
+
+  }
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/TopologyInitializer.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/TopologyInitializer.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/TopologyInitializer.cs	(revision 5209)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  [StorableClass]
+  public abstract class TopologyInitializer : SingleSuccessorOperator, ITopologyInitializer {
+
+    #region Parameters
+    public ScopeTreeLookupParameter<IntegerVector> NeighborsParameter {
+      get { return (ScopeTreeLookupParameter<IntegerVector>)Parameters["Neighbors"]; }
+    }
+    public LookupParameter<IntValue> SwarmSizeParameter {
+      get { return (LookupParameter<IntValue>)Parameters["SwarmSize"]; }
+    }
+
+    #endregion
+
+    #region Parameter Values
+    public ItemArray<IntegerVector> Neighbors {
+      get { return NeighborsParameter.ActualValue; }
+      set { NeighborsParameter.ActualValue = value; }
+    }
+    public int SwarmSize {
+      get { return SwarmSizeParameter.ActualValue.Value; }
+    }
+    #endregion
+
+    #region Construction & Cloning
+    protected TopologyInitializer() {
+      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("Neighbors", "The list of neighbors for each particle."));
+      Parameters.Add(new LookupParameter<IntValue>("SwarmSize", "Number of particles in the swarm."));
+    }
+    [StorableConstructor]
+    protected TopologyInitializer(bool deserializing) : base(deserializing) { }
+    protected TopologyInitializer(TopologyInitializer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    #endregion
+
+  }
+
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/TotallyConnectedParticleUpdater.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/TotallyConnectedParticleUpdater.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/TotallyConnectedParticleUpdater.cs	(revision 5209)
@@ -0,0 +1,67 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  [StorableClass]
+  public class TotallyConnectedParticleUpdater : ParticleUpdater {
+
+    #region Construction & Cloning
+
+    [StorableConstructor]
+    protected TotallyConnectedParticleUpdater(bool deserializing) : base(deserializing) { }
+    protected TotallyConnectedParticleUpdater(ParticleUpdater original, Cloner cloner) : base(original, cloner) { }
+    public TotallyConnectedParticleUpdater() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TotallyConnectedParticleUpdater(this, cloner);
+    }
+
+    #endregion
+
+    public override IOperation Apply() {
+      RealVector velocity = new RealVector(Velocity.Length);
+      RealVector position = new RealVector(Point.Length);
+      double r_p = Random.NextDouble();
+      double r_g = Random.NextDouble();
+      for (int i = 0; i < velocity.Length; i++) {
+        velocity[i] =
+          Velocity[i] * Omega +
+          (PersonalBestPoint[i] - Point[i]) * Phi_P * r_p +
+          (BestPoint[i] - Point[i]) * Phi_G * r_g;
+      }
+      BoundsChecker.Apply(velocity, VelocityBounds);
+      for (int i = 0; i < velocity.Length; i++) {
+        position[i] = Point[i] + velocity[i];
+      }
+      BoundsChecker.Apply(position, Bounds);
+      Point = position;
+      Velocity = velocity;
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/VonNeumannTopologyInitializer.cs
===================================================================
--- /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/VonNeumannTopologyInitializer.cs	(revision 5209)
+++ /branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/VonNeumannTopologyInitializer.cs	(revision 5209)
@@ -0,0 +1,57 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
+
+  public class VonNeumannTopologyInitializer : TopologyInitializer {
+
+    #region Construction & Cloning
+    public VonNeumannTopologyInitializer() { }
+    [StorableConstructor]
+    protected VonNeumannTopologyInitializer(bool deserializing) : base(deserializing) { }
+    protected VonNeumannTopologyInitializer(VonNeumannTopologyInitializer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VonNeumannTopologyInitializer(this, cloner);
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      ItemArray<IntegerVector> neighbors = new ItemArray<IntegerVector>(SwarmSize);
+      for (int i = 0; i<SwarmSize; i++) {
+        neighbors[i] = new IntegerVector(new[] {
+          (SwarmSize + i-2) % SwarmSize,
+          (SwarmSize + i-1) % SwarmSize,
+          (i+1) % SwarmSize,
+          (i+2) % SwarmSize
+        });
+      }
+      Neighbors = neighbors;
+      return base.Apply();
+    }
+
+  }
+}
