Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Symbol.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Symbol.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Symbol.cs	(revision 3269)
@@ -26,118 +26,30 @@
 using System.Linq;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
   [StorableClass]
   [Item("Symbol", "Represents a symbol in a symbolic function tree.")]
-  public abstract class Symbol : Item {
-    private List<List<Symbol>> allowedSubFunctions = new List<List<Symbol>>();
-    private int minArity = -1;
-    private int maxArity = -1;
-    private double tickets = 1.0;
-    private IOperator initializer;
-    private IOperator manipulator;
-    private int minTreeHeight = -1;
-    private int minTreeSize = -1;
+  public abstract class Symbol : ParameterizedNamedItem {
+    #region Parameter Properties
+    public IValueParameter<DoubleValue> TicketsParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Tickets"]; }
+    }
+    #endregion
 
-    private string name;
-    public virtual string Name {
-      get { return name; }
+    #region Properties
+    public DoubleValue Tickets {
+      get { return TicketsParameter.Value; }
       set {
-        if (string.IsNullOrEmpty(value)) throw new ArgumentException();
-        if (value != name) {
-          name = value;
-        }
+        if (value.Value < 0.0) throw new ArgumentException("Number of tickets must be positive");
+        TicketsParameter.Value = value;
       }
     }
+    #endregion
 
-    protected Symbol() {
-      name = this.GetType().Name;
-    }
-
-    public int MinSubTrees {
-      get {
-        return minArity;
-      }
-      protected internal set {
-        if (value < 0) throw new ArgumentException();
-        if (minArity != value) {
-          minArity = value;
-          while (minArity > allowedSubFunctions.Count) allowedSubFunctions.Add(new List<Symbol>());
-          ResetCachedValues();
-        }
-      }
-    }
-
-    public int MaxSubTrees {
-      get {
-        return maxArity;
-      }
-      protected internal set {
-        if (value < 0) throw new ArgumentException();
-        if (value < minArity) throw new ArgumentException();
-        if (value != maxArity) {
-          maxArity = value;
-          while (allowedSubFunctions.Count > maxArity) allowedSubFunctions.RemoveAt(allowedSubFunctions.Count - 1);
-          while (maxArity > allowedSubFunctions.Count) {
-            if (allowedSubFunctions.Count > 0) {
-              // copy the list of allowed sub-functions from the previous slot
-              allowedSubFunctions.Add(new List<Symbol>(allowedSubFunctions[allowedSubFunctions.Count - 1]));
-            } else {
-              // add empty list
-              allowedSubFunctions.Add(new List<Symbol>());
-            }
-          }
-          ResetCachedValues();
-        }
-      }
-    }
-
-
-    public int MinTreeSize {
-      get {
-        if (minTreeSize <= 0) {
-          RecalculateMinimalTreeSize();
-        }
-        // Debug.Assert(minTreeSize > 0);
-        return minTreeSize;
-      }
-    }
-
-    public int MinTreeHeight {
-      get {
-        if (minTreeHeight <= 0) {
-          RecalculateMinimalTreeHeight();
-        }
-        // Debug.Assert(minTreeHeight > 0);
-        return minTreeHeight;
-      }
-    }
-
-    public double Tickets {
-      get { return tickets; }
-      set {
-        if (value < 0.0) throw new ArgumentException("Number of tickets must be positive");
-        if (value != tickets) {
-          tickets = value;
-        }
-      }
-    }
-
-    public IOperator Initializer {
-      get { return initializer; }
-      set {
-        if (initializer != value) {
-          initializer = value;
-        }
-      }
-    }
-
-    public IOperator Manipulator {
-      get { return manipulator; }
-      set {
-        if (manipulator != value) {
-          manipulator = value;
-        }
-      }
+    protected Symbol()
+      : base() {
+      Parameters.Add(new ValueParameter<DoubleValue>("Tickets", new DoubleValue(1.0)));
     }
 
@@ -145,64 +57,4 @@
       return new SymbolicExpressionTreeNode(this);
     }
-
-    public IEnumerable<Symbol> GetAllowedSubFunctions(int index) {
-      if (index < 0 || index > MaxSubTrees) throw new ArgumentException("Index outside of allowed range. index = " + index);
-      return allowedSubFunctions[index];
-    }
-
-    public void AddAllowedSubFunction(Symbol symbol, int index) {
-      if (index < 0 || index > MaxSubTrees) throw new ArgumentException("Index outside of allowed range. index = " + index);
-      if (allowedSubFunctions[index] == null) {
-        allowedSubFunctions[index] = new List<Symbol>();
-      }
-      if (!allowedSubFunctions[index].Contains(symbol)) {
-        allowedSubFunctions[index].Add(symbol);
-      }
-      ResetCachedValues();
-    }
-    public void RemoveAllowedSubFunction(Symbol symbol, int index) {
-      if (index < 0 || index > MaxSubTrees) throw new ArgumentException("Index outside of allowed range. index = " + index);
-      if (allowedSubFunctions[index].Contains(symbol)) {
-        allowedSubFunctions[index].Remove(symbol);
-        ResetCachedValues();
-      }
-    }
-
-    private void ResetCachedValues() {
-      minTreeHeight = -1;
-      minTreeSize = -1;
-    }
-
-    public bool IsAllowedSubFunction(Symbol symbol, int index) {
-      return GetAllowedSubFunctions(index).Contains(symbol);
-    }
-
-    private void RecalculateMinimalTreeSize() {
-      if (MinSubTrees == 0) minTreeSize = 1;
-      else {
-        minTreeSize = int.MaxValue; // prevent infinite recursion        
-        minTreeSize = 1 + (from slot in Enumerable.Range(0, MinSubTrees)
-                           let minForSlot = (from function in GetAllowedSubFunctions(slot)
-                                             where function != this
-                                             select function.MinTreeSize).DefaultIfEmpty(0).Min()
-                           select minForSlot).Sum();
-      }
-    }
-
-    private void RecalculateMinimalTreeHeight() {
-      if (MinSubTrees == 0) minTreeHeight = 1;
-      else {
-        minTreeHeight = int.MaxValue;
-        minTreeHeight = 1 + (from slot in Enumerable.Range(0, MinSubTrees)
-                             let minForSlot = (from function in GetAllowedSubFunctions(slot)
-                                               where function != this
-                                               select function.MinTreeHeight).DefaultIfEmpty(0).Min()
-                             select minForSlot).Max();
-      }
-    }
-
-    public override string ToString() {
-      return name;
-    }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeCreator.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeCreator.cs	(revision 3269)
@@ -20,4 +20,5 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
@@ -72,5 +73,9 @@
       SymbolicExpressionTreeParameter.ActualValue = Create(RandomParameter.ActualValue, SymbolicExpressionGrammarParameter.ActualValue,
         MaxTreeSizeParameter.ActualValue, MaxTreeHeightParameter.ActualValue);
-      return base.Apply();
+
+      foreach (var node in SymbolicExpressionTreeParameter.ActualValue.IterateNodesPostfix()) {
+        node.ResetLocalParameters(RandomParameter.ActualValue);
+      }
+      return null;
     }
 
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeNode.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeNode.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeNode.cs	(revision 3269)
@@ -76,12 +76,7 @@
       return maxHeight + 1;
     }
-
-    //public virtual IOperation CreateShakingOperation(IScope scope) {
-    //  return null;
-    //}
-
-    //public virtual IOperation CreateInitOperation(IScope scope) {
-    //  return null;
-    //}
+    
+    public virtual void ResetLocalParameters(IRandom random) { }
+    public virtual void ShakeLocalParameters(IRandom random, double shakingFactor) { }
 
     protected internal virtual void AddSubTree(SymbolicExpressionTreeNode tree) {
Index: trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Symbols/Prog3.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Symbols/Prog3.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Symbols/Prog3.cs	(revision 3269)
@@ -23,8 +23,6 @@
 namespace HeuristicLab.Problems.ArtificialAnt {
   public sealed class Prog3 : Symbol {
-
     public Prog3()
       : base() {
-      MinSubTrees = 3; MaxSubTrees = 3;
     }
   }
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/ArithmeticExpressionGrammar.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/ArithmeticExpressionGrammar.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/ArithmeticExpressionGrammar.cs	(revision 3269)
@@ -29,11 +29,28 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.GeneralSymbols;
 using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Symbols;
+using HeuristicLab.Data;
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic {
   [StorableClass]
-  public class ArithmeticExpressionGrammar : Item, ISymbolicExpressionGrammar {
+  public class ArithmeticExpressionGrammar : NamedItemCollection<Symbol>, ISymbolicExpressionGrammar {
+
+    private List<string> variableNames = new List<string>();
+    public IEnumerable<string> VariableNames {
+      get { return variableNames; }
+      set {
+        variableNames = new List<string>(value);
+        var variable = (HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Symbols.Variable)allSymbols[5];
+        variable.VariableNames = new ItemList<HeuristicLab.Data.StringValue>(variableNames.Select(x => new StringValue(x)));
+      }
+    }
 
     public ArithmeticExpressionGrammar()
-      : base() {
+      : this(allSymbols) {
     }
+
+    public ArithmeticExpressionGrammar(IEnumerable<Symbol> symbols)
+      : base(symbols) {
+      allSymbols = new List<Symbol>(symbols);
+    }
+
     #region ISymbolicExpressionGrammar Members
     [Storable]
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SimpleArithmeticExpressionEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SimpleArithmeticExpressionEvaluator.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SimpleArithmeticExpressionEvaluator.cs	(revision 3269)
@@ -53,5 +53,5 @@
       if (node.Symbol is HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Symbols.Variable) {
         var variableTreeNode = node as VariableTreeNode;
-        return dataset[row, 1 /*dataset.VariableIndex(variableTreeNode.VariableName)*/] * 1.0; //variableTreeNode.Weight;
+        return dataset[row, dataset.VariableIndex(variableTreeNode.VariableName)] * variableTreeNode.Weight;
       } else if (node.Symbol is Constant) {
         return ((ConstantTreeNode)node).Value;
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs	(revision 3269)
@@ -111,6 +111,6 @@
       get { return EvaluatorParameter.Value; }
     }
-    public ISymbolicExpressionGrammar FunctionTreeGrammar {
-      get { return FunctionTreeGrammarParameter.Value; }
+    public ArithmeticExpressionGrammar FunctionTreeGrammar {
+      get { return (ArithmeticExpressionGrammar)FunctionTreeGrammarParameter.Value; }
     }
     public ISingleObjectiveSolutionsVisualizer Visualizer {
@@ -147,4 +147,5 @@
       creator.SymbolicExpressionTreeParameter.ActualName = "SymbolicRegressionModel";
       evaluator.QualityParameter.ActualName = "TrainingMeanSquaredError";
+      InputVariablesParameter.ValueChanged += new EventHandler(InputVariablesParameter_ValueChanged);
       ParameterizeSolutionCreator();
       ParameterizeEvaluator();
@@ -152,4 +153,8 @@
 
       Initialize();
+    }
+
+    void InputVariablesParameter_ValueChanged(object sender, EventArgs e) {
+      FunctionTreeGrammar.VariableNames = InputVariablesParameter.Value.Select(x => x.Value);
     }
 
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/Constant.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/Constant.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/Constant.cs	(revision 3269)
@@ -21,6 +21,38 @@
 
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Random;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Symbols {
+  [StorableClass]
+  [Item("Constant", "Represents a constant value.")]
   public sealed class Constant : Symbol {
+    #region Parameter Properties
+    public IValueParameter<DoubleValue> MinValueParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["MinValue"]; }
+    }
+    public IValueParameter<DoubleValue> MaxValueParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["MaxValue"]; }
+    }
+    #endregion
+    #region Propeties
+    public DoubleValue MinValue {
+      get { return MinValueParameter.Value; }
+      set { MinValueParameter.Value = value; }
+    }
+    public DoubleValue MaxValue {
+      get { return MaxValueParameter.Value; }
+      set { MaxValueParameter.Value = value; }
+    }
+    #endregion
+    public Constant()
+      : base() {
+      Parameters.Add(new ValueParameter<DoubleValue>("MinValue", "The minimal value of the constant.", new DoubleValue(-20.0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("MaxValue", "The maximal value of the constant.", new DoubleValue(20.0)));
+    }
+
     public override SymbolicExpressionTreeNode CreateTreeNode() {
       return new ConstantTreeNode(this);
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/ConstantTreeNode.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/ConstantTreeNode.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/ConstantTreeNode.cs	(revision 3269)
@@ -24,7 +24,13 @@
 using System.Collections.Generic;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Random;
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Symbols {
   [StorableClass]
   public sealed class ConstantTreeNode : SymbolicExpressionTreeTerminalNode {
+    public new Constant Symbol {
+      get { return (Constant)base.Symbol; }
+    }
     public override bool HasLocalParameters {
       get {
@@ -39,5 +45,4 @@
       set { constantValue = value; }
     }
-
     // copy constructor
     private ConstantTreeNode(ConstantTreeNode original)
@@ -48,4 +53,10 @@
     public ConstantTreeNode(Constant constantSymbol) : base(constantSymbol) { }
 
+    public override void ResetLocalParameters(IRandom random) {
+      base.ResetLocalParameters(random);
+      var range = Symbol.MaxValue.Value - Symbol.MaxValue.Value;
+      Value = random.NextDouble() * range - Symbol.MinValue.Value;
+    }
+
     public override object Clone() {
       return new ConstantTreeNode(this);
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/Variable.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/Variable.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/Variable.cs	(revision 3269)
@@ -21,6 +21,46 @@
 
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Random;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Symbols {
+  [StorableClass]
+  [Item("Variable", "Represents a variable value.")]
   public sealed class Variable : Symbol {
+    #region Parameter Properties
+    public IValueParameter<DoubleValue> WeightNuParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["WeightNu"]; }
+    }
+    public IValueParameter<DoubleValue> WeightSigmaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["WeightSigma"]; }
+    }
+    public IValueParameter<ItemList<StringValue>> VariableNamesParameter {
+      get { return (IValueParameter<ItemList<StringValue>>)Parameters["VariableNames"]; }
+    }
+    #endregion
+    #region Properties
+    public DoubleValue WeightNu {
+      get { return WeightNuParameter.Value; }
+      set { WeightNuParameter.Value = value; }
+    }
+    public DoubleValue WeightSigma {
+      get { return WeightSigmaParameter.Value; }
+      set { WeightSigmaParameter.Value = value; }
+    }
+    public ItemList<StringValue> VariableNames {
+      get { return VariableNamesParameter.Value; }
+      set { VariableNamesParameter.Value = value; }
+    }
+    #endregion
+    public Variable()
+      : base() {
+      Parameters.Add(new ValueParameter<DoubleValue>("WeightNu", "The mean value for the initialization of weight ((N(nu, sigma)).", new DoubleValue(1.0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("WeightSigma", "The sigma value for the initialization of weight (N(nu, sigma))", new DoubleValue(1.0)));
+      Parameters.Add(new ValueParameter<ItemList<StringValue>>("VariableNames", "The list of possible variable names for initialization."));
+    }
+
     public override SymbolicExpressionTreeNode CreateTreeNode() {
       return new VariableTreeNode(this);
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/VariableTreeNode.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/VariableTreeNode.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Symbols/VariableTreeNode.cs	(revision 3269)
@@ -24,8 +24,13 @@
 using System.Collections.Generic;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Random;
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Symbols {
   [StorableClass]
   public sealed class VariableTreeNode : SymbolicExpressionTreeTerminalNode {
-    
+    public new Variable Symbol {
+      get { return (Variable)base.Symbol; }
+    }
     private double weight;
     [Storable]
@@ -50,4 +55,12 @@
     public VariableTreeNode(Variable variableSymbol) : base(variableSymbol) { }
 
+    public override void ResetLocalParameters(IRandom random) {
+      base.ResetLocalParameters(random);
+      var normalDistributedRNG = new NormalDistributedRandom(random, Symbol.WeightNu.Value, Symbol.WeightSigma.Value);
+      weight = normalDistributedRNG.NextDouble();
+      int variableIndex = random.Next(0, Symbol.VariableNames.Count);
+      variableName = Symbol.VariableNames[variableIndex].Value;
+    }
+
     public override object Clone() {
       return new VariableTreeNode(this);
Index: trunk/sources/HeuristicLab.Random/3.3/HeuristicLab.Random-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Random/3.3/HeuristicLab.Random-3.3.csproj	(revision 3268)
+++ trunk/sources/HeuristicLab.Random/3.3/HeuristicLab.Random-3.3.csproj	(revision 3269)
@@ -93,6 +93,8 @@
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="NormalRandomizer.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="RandomCreator.cs" />
+    <Compile Include="UniformRandomizer.cs" />
   </ItemGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Random/3.3/NormalRandomizer.cs
===================================================================
--- trunk/sources/HeuristicLab.Random/3.3/NormalRandomizer.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Random/3.3/NormalRandomizer.cs	(revision 3269)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -26,4 +26,6 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Random {
@@ -31,32 +33,31 @@
   /// Normally distributed random number generator.
   /// </summary>
-  [EmptyStorableClass]
-  public class NormalRandomizer : OperatorBase {
-    private static int MAX_NUMBER_OF_TRIES = 100;
-
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Initializes the value of variable 'Value' to a random value normally distributed with 'Mu' and 'Sigma'."; }
+  [StorableClass]
+  [Item("NormalRandomizer", "Initializes the value of variable 'Value' to a random value normally distributed with parameters 'Mu' and 'Sigma'")]
+  public class NormalRandomizer : SingleSuccessorOperator {
+    #region parameter properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
-
-    /// <summary>
-    /// Gets or sets the value for µ.
-    /// </summary>
-    /// <remarks>Gets or sets the variable with the name <c>Mu</c> through the method 
-    /// <see cref="OperatorBase.GetVariable"/> of class <see cref="OperatorBase"/>.</remarks>
-    public double Mu {
-      get { return ((DoubleData)GetVariable("Mu").Value).Data; }
-      set { ((DoubleData)GetVariable("Mu").Value).Data = value; }
+    public IValueLookupParameter<DoubleValue> MuParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Mu"]; }
     }
-    /// <summary>
-    /// Gets or sets the value for sigma.
-    /// </summary>
-    /// <remarks>Gets or sets the variable with the name <c>Sigma</c> through the method 
-    /// <see cref="OperatorBase.GetVariable"/> of class <see cref="OperatorBase"/>.</remarks>
-    public double Sigma {
-      get { return ((DoubleData)GetVariable("Sigma").Value).Data; }
-      set { ((DoubleData)GetVariable("Sigma").Value).Data = value; }
+    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
     /// <summary>
     /// Initializes a new instance of <see cref="NormalRandomizer"/> with four variable infos
@@ -64,60 +65,21 @@
     /// </summary>
     public NormalRandomizer() {
-      AddVariableInfo(new VariableInfo("Mu", "Parameter mu of the normal distribution", typeof(DoubleData), VariableKind.None));
-      GetVariableInfo("Mu").Local = true;
-      AddVariable(new Variable("Mu", new DoubleData(0.0)));
-
-      AddVariableInfo(new VariableInfo("Sigma", "Parameter sigma of the normal distribution", typeof(DoubleData), VariableKind.None));
-      GetVariableInfo("Sigma").Local = true;
-      AddVariable(new Variable("Sigma", new DoubleData(1.0)));
-
-      AddVariableInfo(new VariableInfo("Value", "The value to manipulate (actual type is one of: IntData, DoubleData, ConstrainedIntData, ConstrainedDoubleData)", typeof(IObjectData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Random", "The random generator to use", typeof(MersenneTwister), VariableKind.In));
+      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."));
     }
 
     /// <summary>
-    /// Generates a new normally distributed random variable and assigns it to the specified variable
-    /// in the given <paramref name="scope"/>.
+    /// Generates a new normally distributed random variable and assigns it to the specified variable.
     /// </summary>
-    /// <param name="scope">The scope where to assign the new random value to.</param>
-    /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      IObjectData value = GetVariableValue<IObjectData>("Value", scope, false);
-      MersenneTwister mt = GetVariableValue<MersenneTwister>("Random", scope, true);
-      double mu = GetVariableValue<DoubleData>("Mu", scope, true).Data;
-      double sigma = GetVariableValue<DoubleData>("Sigma", scope, true).Data;
+    public override IOperation Apply() {
+      IRandom random = RandomParameter.ActualValue;
+      double mu = MuParameter.ActualValue.Value;
+      double sigma = SigmaParameter.ActualValue.Value;
 
-      NormalDistributedRandom n = new NormalDistributedRandom(mt, mu, sigma);
-      RandomizeNormal(value, n);
+      NormalDistributedRandom normalRandom = new NormalDistributedRandom(random, mu, sigma);
+      ValueParameter.ActualValue = new DoubleValue(normalRandom.NextDouble());
       return null;
-    }
-
-    private void RandomizeNormal(IObjectData value, NormalDistributedRandom n) {
-      // dispatch manually based on dynamic type
-      if (value is IntData)
-        RandomizeNormal((IntData)value, n);
-      else if (value is DoubleData)
-        RandomizeNormal((DoubleData)value, n);
-      else throw new InvalidOperationException("Can't handle type " + value.GetType().Name);
-    }
-
-    /// <summary>
-    /// Generates a new double random number based on a continuous, normally distributed random number
-    /// generator <paramref name="normal"/>.
-    /// </summary>
-    /// <param name="data">The double object where to assign the new value to.</param>
-    /// <param name="normal">The continuous, normally distributed random variable.</param>
-    public void RandomizeNormal(DoubleData data, NormalDistributedRandom normal) {
-      data.Data = normal.NextDouble();
-    }
-
-    /// <summary>
-    /// Generates a new int random number based on a continuous, normally distributed random number 
-    /// generator <paramref name="normal"/>.
-    /// </summary>
-    /// <param name="data">The int object where to assign the new value to.</param>
-    /// <param name="normal">The continuous, normally distributed random variable.</param>
-    public void RandomizeNormal(IntData data, NormalDistributedRandom normal) {
-      data.Data = (int)Math.Round(normal.NextDouble());
     }
   }
Index: trunk/sources/HeuristicLab.Random/3.3/UniformRandomizer.cs
===================================================================
--- trunk/sources/HeuristicLab.Random/3.3/UniformRandomizer.cs	(revision 3268)
+++ trunk/sources/HeuristicLab.Random/3.3/UniformRandomizer.cs	(revision 3269)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -26,4 +26,6 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Random {
@@ -31,30 +33,31 @@
   /// Uniformly distributed random number generator.
   /// </summary>
-  [EmptyStorableClass]
-  public class UniformRandomizer : OperatorBase {
-    private static int MAX_NUMBER_OF_TRIES = 100;
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Initializes the value of variable 'Value' to a random value uniformly distributed between 'Min' and 'Max' (exclusive)"; }
+  [StorableClass]
+  [Item("UniformRandomizer", "Initializes the value of variable 'Value' to a random value uniformly distributed between 'Min' and 'Max'")]
+  public class UniformRandomizer : SingleSuccessorOperator {
+    #region parameter properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
-
-    /// <summary>
-    /// Gets or sets the maximum value of the random number generator (exclusive).
-    /// </summary>
-    /// <remarks>Gets or sets the variable with name <c>Max</c> through the 
-    /// <see cref="OperatorBase.GetVariable"/> method of class <see cref="OperatorBase"/>.</remarks>
-    public double Max {
-      get { return ((DoubleData)GetVariable("Max").Value).Data; }
-      set { ((DoubleData)GetVariable("Max").Value).Data = value; }
+    public IValueLookupParameter<DoubleValue> MinParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Min"]; }
     }
-    /// <summary>
-    /// Gets or sets the minimum value of the random number generator.
-    /// </summary>
-    /// <remarks>Gets or sets the variable with name <c>Min</c> through the 
-    /// <see cref="OperatorBase.GetVariable"/> method of class <see cref="OperatorBase"/>.</remarks>
-    public double Min {
-      get { return ((DoubleData)GetVariable("Min").Value).Data; }
-      set { ((DoubleData)GetVariable("Min").Value).Data = value; }
+    public IValueLookupParameter<DoubleValue> MaxParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Max"]; }
     }
+    public ILookupParameter<DoubleValue> ValueParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Value"]; }
+    }
+    #endregion
+    #region Properties
+    public DoubleValue Min {
+      get { return MinParameter.ActualValue; }
+      set { MinParameter.ActualValue = value; }
+    }
+    public DoubleValue Max {
+      get { return MaxParameter.ActualValue; }
+      set { MaxParameter.ActualValue = value; }
+    }
+    #endregion
 
     /// <summary>
@@ -63,14 +66,10 @@
     /// between 0.0 and 1.0.
     /// </summary>
-    public UniformRandomizer() {
-      AddVariableInfo(new VariableInfo("Value", "The value to manipulate (type is one of: IntData, ConstrainedIntData, DoubleData, ConstrainedDoubleData)", typeof(IObjectData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Random", "The random generator to use", typeof(MersenneTwister), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Min", "Lower bound of the uniform distribution (inclusive)", typeof(DoubleData), VariableKind.None));
-      GetVariableInfo("Min").Local = true;
-      AddVariable(new Variable("Min", new DoubleData(0.0)));
-
-      AddVariableInfo(new VariableInfo("Max", "Upper bound of the uniform distribution (exclusive)", typeof(DoubleData), VariableKind.None));
-      GetVariableInfo("Max").Local = true;
-      AddVariable(new Variable("Max", new DoubleData(1.0)));
+    public UniformRandomizer()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "A random generator that supplies uniformly distributed values."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Min", "The minimal allowed value (inclusive)"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Max", "The maximal allowed value (exclusive)"));
+      Parameters.Add(new LookupParameter<DoubleValue>("Value", "The value that should be set to a random value."));
     }
 
@@ -78,58 +77,12 @@
     /// Generates a new uniformly distributed random variable.
     /// </summary>
-    /// <param name="scope">The scope where to apply the random number generator.</param>
-    /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      IObjectData value = GetVariableValue<IObjectData>("Value", scope, false);
-      MersenneTwister mt = GetVariableValue<MersenneTwister>("Random", scope, true);
-      double min = GetVariableValue<DoubleData>("Min", scope, true).Data;
-      double max = GetVariableValue<DoubleData>("Max", scope, true).Data;
+    public override IOperation Apply() {
+      IRandom random = RandomParameter.ActualValue;
+      double min = MinParameter.ActualValue.Value;
+      double max = MaxParameter.ActualValue.Value;
 
-      RandomizeUniform(value, mt, min, max);
+      ValueParameter.ActualValue = new DoubleValue(random.NextDouble() * (max - min) + min);
       return null;
     }
-
-    /// <summary>
-    /// Generates a new random number depending on the type of the <paramref name="value"/>.
-    /// </summary>
-    /// <exception cref="ArgumentException">Thrown when an unhandleable type appears.</exception>
-    /// <param name="value">The object whose data should be a new randomly generated number.</param>
-    /// <param name="mt">The MersenneTwister to generate a new random number.</param>
-    /// <param name="min">The left border of the interval in which the next random number has to lie.</param>
-    /// <param name="max">The right border (exclusive) of the interval in which the next random number
-    /// has to lie.</param>
-    private void RandomizeUniform(IObjectData value, MersenneTwister mt, double min, double max) {
-      // Dispatch manually based on dynamic type,
-      // a bit awkward but necessary until we create a better type hierarchy for numeric types (gkronber 15.11.2008).
-      if (value is DoubleData)
-        RandomizeUniform((DoubleData)value, mt, min, max);
-      else if (value is IntData)
-        RandomizeUniform((IntData)value, mt, min, max);
-      else throw new ArgumentException("Can't handle type " + value.GetType().Name);
-    }
-
-      /// <summary>
-      /// Generates a new double random number.
-      /// </summary>
-      /// <param name="data">The double object which the new value is assigned to.</param>
-      /// <param name="mt">The random number generator.</param>
-      /// <param name="min">The left border of the interval in which the next random number has to lie.</param>
-      /// <param name="max">The right border (exclusive) of the interval in which the next random number
-      /// has to lie.</param>
-      public void RandomizeUniform(DoubleData data, MersenneTwister mt, double min, double max) {
-        data.Data = mt.NextDouble() * (max - min) + min;
-      }
-
-      /// <summary>
-      /// Generates a new int random number.
-      /// </summary>
-      /// <param name="data">The int object which the new value is assigned to.</param>
-      /// <param name="mt">The random number generator.</param>
-      /// <param name="min">The left border of the interval in which the next random number has to lie.</param>
-      /// <param name="max">The right border (exclusive) of the interval in which the next random number
-      /// has to lie.</param>
-      public void RandomizeUniform(IntData data, MersenneTwister mt, double min, double max) {
-        data.Data = (int)Math.Floor(mt.NextDouble() * (max - min) + min);
-      }
-    }
+  }
 }
