Index: /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/HeuristicLab.Random-3.3.csproj
===================================================================
--- /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/HeuristicLab.Random-3.3.csproj	(revision 17243)
+++ /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/HeuristicLab.Random-3.3.csproj	(revision 17244)
@@ -120,4 +120,6 @@
     <Compile Include="GammaDistributedRandom.cs" />
     <Compile Include="ListExtensions.cs" />
+    <Compile Include="NormalDistributedRandomPolar.cs" />
+    <Compile Include="NormalRandomizerPolar.cs" />
     <Compile Include="RandomSeedGenerator.cs" />
     <Compile Include="UniformDistributedRandom.cs" />
Index: /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalDistributedRandom.cs
===================================================================
--- /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalDistributedRandom.cs	(revision 17243)
+++ /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalDistributedRandom.cs	(revision 17244)
@@ -34,4 +34,5 @@
   [Item("NormalDistributedRandom", "A pseudo random number generator which uses the Ziggurat method to create normally distributed random numbers.")]
   [StorableType("240F7050-C05B-4E85-82C3-2871FE2138B1")]
+  [Obsolete("Use NormalDistributedRandomPolar instead.")]
   public sealed class NormalDistributedRandom : Item, IRandom {
     [Storable]
@@ -449,8 +450,4 @@
     };
 
-    /// <summary>
-    /// Used by HeuristicLab.Persistence to initialize new instances during deserialization.
-    /// </summary>
-    /// <param name="deserializing">true, if the constructor is called during deserialization.</param>
     [StorableConstructor]
     private NormalDistributedRandom(StorableConstructorFlag _) : base(_) { }
@@ -480,5 +477,5 @@
     /// <summary>
     /// Initializes a new instance of <see cref="NormalDistributedRandom"/> with the given parameters.
-    /// <note type="caution"> No CopyConstructor! The random number generator is not copied!</note>
+    /// <note type="caution">The random number generator is not copied!</note>
     /// </summary>    
     /// <param name="uniformRandom">The random number generator.</param>
@@ -537,7 +534,5 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone through <see cref="cloner.Clone"/> method of helper class 
-    /// <see cref="Auxiliary"/>.</remarks>
-    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
+    /// <remarks>Deep clone through <see cref="cloner.Clone"/> method of helper class.</remarks>
     /// <returns>The cloned object as <see cref="NormalDistributedRandom"/>.</returns>
     public override IDeepCloneable Clone(Cloner cloner) {
Index: /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalDistributedRandomPolar.cs
===================================================================
--- /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalDistributedRandomPolar.cs	(revision 17244)
+++ /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalDistributedRandomPolar.cs	(revision 17244)
@@ -0,0 +1,162 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 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 HEAL.Attic;
+
+namespace HeuristicLab.Random {
+
+  /// <summary>
+  /// Normally distributed random variable.
+  /// Uses Marsaglia's polar method
+  /// </summary>
+  [Item("NormalDistributedRandomPolar", "A pseudo random number generator which uses Marsaglia's polar method to create normally distributed random numbers.")]
+  public sealed class NormalDistributedRandomPolar : Item, IRandom {
+    [Storable]
+    private double mu;
+    /// <summary>
+    /// Gets or sets the value for µ.
+    /// </summary>
+    public double Mu {
+      get { return mu; }
+      set { mu = value; }
+    }
+
+    [Storable]
+    private double sigma;
+    /// <summary>
+    /// Gets or sets the value for sigma.
+    /// </summary>
+    public double Sigma {
+      get { return sigma; }
+      set { sigma = value; }
+    }
+
+    [Storable]
+    private IRandom uniform;
+
+
+    [StorableConstructor]
+    private NormalDistributedRandomPolar(StorableConstructorFlag _) : base(_) { }
+
+    private NormalDistributedRandomPolar(NormalDistributedRandomPolar original, Cloner cloner)
+      : base(original, cloner) {
+      uniform = cloner.Clone(original.uniform);
+      mu = original.mu;
+      sigma = original.sigma;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="NormalDistributedRandomPolar"/> with µ = 0 and sigma = 1
+    /// and a new random number generator.
+    /// </summary>
+    public NormalDistributedRandomPolar() {
+      this.mu = 0.0;
+      this.sigma = 1.0;
+      this.uniform = new MersenneTwister();
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="NormalDistributedRandomPolar"/> with the given parameters.
+    /// <note type="caution"> The random number generator is not copied!</note>
+    /// </summary>    
+    /// <param name="uniformRandom">The random number generator.</param>
+    /// <param name="mu">The value for µ.</param>
+    /// <param name="sigma">The value for sigma.</param>
+    public NormalDistributedRandomPolar(IRandom uniformRandom, double mu, double sigma) {
+      this.mu = mu;
+      this.sigma = sigma;
+      this.uniform = uniformRandom;
+    }
+
+    #region IRandom Members
+
+    /// <inheritdoc cref="IRandom.Reset()"/>
+    public void Reset() {
+      uniform.Reset();
+    }
+
+    /// <inheritdoc cref="IRandom.Reset(int)"/>
+    public void Reset(int seed) {
+      uniform.Reset(seed);
+    }
+
+    /// <summary>
+    /// This method is not implemented.
+    /// </summary>
+    public int Next() {
+      throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// This method is not implemented.
+    /// </summary>
+    public int Next(int maxVal) {
+      throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// This method is not implemented.
+    /// </summary>
+    public int Next(int minVal, int maxVal) {
+      throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Generates a new double random number.
+    /// </summary>
+    /// <returns>A double random number.</returns>
+    public double NextDouble() {
+      return NormalDistributedRandomPolar.NextDouble(uniform, mu, sigma);
+    }
+
+    #endregion
+
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <returns>The cloned object as <see cref="NormalDistributedRandomPolar"/>.</returns>
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NormalDistributedRandomPolar(this, cloner);
+    }
+
+
+    /**
+     * Polar method due to Marsaglia.
+     *
+     * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
+     * New York, 1986, Ch. V, Sect. 4.4.
+     */
+    public static double NextDouble(IRandom uniformRandom, double mu, double sigma) {
+      // we don't use spare numbers (efficency loss but easier for multi-threaded code)
+      double u, v, s;
+      do {
+        u = uniformRandom.NextDouble() * 2 - 1;
+        v = uniformRandom.NextDouble() * 2 - 1;
+        s = u * u + v * v;
+      } while (s >= 1 || s == 0);
+      s = Math.Sqrt(-2.0 * Math.Log(s) / s);
+      return mu + sigma * u * s; 
+    }
+  }
+}
Index: /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalRandomizer.cs
===================================================================
--- /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalRandomizer.cs	(revision 17243)
+++ /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalRandomizer.cs	(revision 17244)
@@ -26,4 +26,5 @@
 using HeuristicLab.Parameters;
 using HEAL.Attic;
+using System;
 
 namespace HeuristicLab.Random {
@@ -33,4 +34,5 @@
   [StorableType("0EAF4184-6C98-4C9D-80A1-09A42E03450E")]
   [Item("NormalRandomizer", "Initializes the value of variable 'Value' to a random value normally distributed with parameters 'Mu' and 'Sigma'")]
+  [Obsolete("Use NormalRandomizerPolar instead.")]
   public class NormalRandomizer : SingleSuccessorOperator {
     #region Parameter Properties
Index: /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalRandomizerPolar.cs
===================================================================
--- /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalRandomizerPolar.cs	(revision 17244)
+++ /branches/3027-NormalDistribution/HeuristicLab.Random/3.3/NormalRandomizerPolar.cs	(revision 17244)
@@ -0,0 +1,93 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 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.Parameters;
+using HEAL.Attic;
+
+namespace HeuristicLab.Random {
+  /// <summary>
+  /// Normally distributed random number generator using the Marsaglia's polar method.
+  /// </summary>
+  [Item("NormalRandomizerPolar", "Initializes the value of variable 'Value' to a random value normally distributed with parameters 'Mu' and 'Sigma'")]
+  [StorableType("24927018-F729-449C-97BB-D41184F64A61")]
+  public class NormalRandomizerPolar : SingleSuccessorOperator {
+    #region Parameter Properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<DoubleValue> MuParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Mu"]; }
+    }
+    public IValueLookupParameter<DoubleValue> SigmaParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Sigma"]; }
+    }
+    public ILookupParameter<DoubleValue> ValueParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Value"]; }
+    }
+    #endregion
+
+    #region Properties
+    public DoubleValue Mu {
+      get { return MuParameter.ActualValue; }
+      set { MuParameter.ActualValue = value; }
+    }
+    public DoubleValue Max {
+      get { return SigmaParameter.ActualValue; }
+      set { SigmaParameter.ActualValue = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected NormalRandomizerPolar(StorableConstructorFlag _) : base(_) { }
+    protected NormalRandomizerPolar(NormalRandomizerPolar original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="NormalRandomizerPolar"/> with four variable infos
+    /// (<c>Mu</c>, <c>Sigma</c>, <c>Value</c> and <c>Random</c>).
+    /// </summary>
+    public NormalRandomizerPolar() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "A random generator that supplies uniformly distributed values."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Mu", "Mu parameter of the normal distribution (N(mu,sigma))."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Sigma", "Sigma parameter of the normal distribution (N(mu,sigma))."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Value", "The value that should be set to a random value."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NormalRandomizerPolar(this, cloner);
+    }
+
+    /// <summary>
+    /// Generates a new normally distributed random variable and assigns it to the specified variable.
+    /// </summary>
+    public override IOperation Apply() {
+      IRandom random = RandomParameter.ActualValue;
+      double mu = MuParameter.ActualValue.Value;
+      double sigma = SigmaParameter.ActualValue.Value;
+
+      NormalDistributedRandomPolar normalRandom = new NormalDistributedRandomPolar(random, mu, sigma);
+      ValueParameter.ActualValue = new DoubleValue(normalRandom.NextDouble());
+      return base.Apply();
+    }
+  }
+}
