Index: trunk/sources/HeuristicLab.Functions/Constant.cs
===================================================================
--- trunk/sources/HeuristicLab.Functions/Constant.cs	(revision 424)
+++ trunk/sources/HeuristicLab.Functions/Constant.cs	(revision 425)
@@ -28,4 +28,6 @@
 using HeuristicLab.Constraints;
 using HeuristicLab.DataAnalysis;
+using HeuristicLab.Operators;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Functions {
@@ -48,7 +50,45 @@
       AddVariable(value);
 
+      SetupInitialization();
+      SetupManipulation();
+
       // constant can't have suboperators
       AddConstraint(new NumberOfSubOperatorsConstraint(0, 0));
     }
+
+    private void SetupInitialization() {
+      // initialization operator
+      AddVariableInfo(new VariableInfo(INITIALIZATION, "Initialization operator-graph for constants", typeof(IOperatorGraph), VariableKind.None));
+      GetVariableInfo(INITIALIZATION).Local = false;
+      CombinedOperator combinedOp = new CombinedOperator();
+      SequentialProcessor initSeq = new SequentialProcessor();
+      UniformRandomizer randomizer = new UniformRandomizer();
+      randomizer.Min = -20.0;
+      randomizer.Max = 20.0;
+
+      combinedOp.OperatorGraph.AddOperator(initSeq);
+      combinedOp.OperatorGraph.AddOperator(randomizer);
+      combinedOp.OperatorGraph.InitialOperator = initSeq;
+      initSeq.AddSubOperator(randomizer);
+      AddVariable(new HeuristicLab.Core.Variable(INITIALIZATION, combinedOp));
+    }
+
+    private void SetupManipulation() {
+      // manipulation operator
+      AddVariableInfo(new VariableInfo(MANIPULATION, "Manipulation operator-graph for constants", typeof(IOperatorGraph), VariableKind.None));
+      GetVariableInfo(MANIPULATION).Local = false;
+      CombinedOperator combinedOp = new CombinedOperator();
+      SequentialProcessor manipulationSeq = new SequentialProcessor();
+      NormalRandomAdder valueAdder = new NormalRandomAdder();
+      valueAdder.Mu = 0.0;
+      valueAdder.Sigma = 0.1;
+
+      combinedOp.OperatorGraph.AddOperator(manipulationSeq);
+      combinedOp.OperatorGraph.AddOperator(valueAdder);
+      combinedOp.OperatorGraph.InitialOperator = manipulationSeq;
+      manipulationSeq.AddSubOperator(valueAdder);
+      AddVariable(new HeuristicLab.Core.Variable(MANIPULATION, combinedOp));
+    }
+
     public override void Accept(IFunctionVisitor visitor) {
       visitor.Visit(this);
Index: trunk/sources/HeuristicLab.Functions/Differential.cs
===================================================================
--- trunk/sources/HeuristicLab.Functions/Differential.cs	(revision 424)
+++ trunk/sources/HeuristicLab.Functions/Differential.cs	(revision 425)
@@ -28,4 +28,6 @@
 using HeuristicLab.Constraints;
 using HeuristicLab.DataAnalysis;
+using HeuristicLab.Operators;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Functions {
@@ -60,10 +62,81 @@
 
       ConstrainedIntData sampleOffset = new ConstrainedIntData();
-      // initialize a totally arbitrary default range for sampleoffset = [-10, 10]
-      sampleOffset.AddConstraint(new IntBoundedConstraint(0, 0));
+      // initialize a sample offset for static models
+      IntBoundedConstraint offsetConstraint = new IntBoundedConstraint(0, 0);
+      offsetConstraint.LowerBoundIncluded = true;
+      offsetConstraint.UpperBoundIncluded = true;
+      sampleOffset.AddConstraint(offsetConstraint);
       AddVariable(new HeuristicLab.Core.Variable(OFFSET, sampleOffset));
+
+      SetupInitialization();
+      SetupManipulation();
 
       // variable can't have suboperators
       AddConstraint(new NumberOfSubOperatorsConstraint(0, 0));
+    }
+
+    private void SetupInitialization() {
+      AddVariableInfo(new VariableInfo(INITIALIZATION, "Initialization operator for differentials", typeof(CombinedOperator), VariableKind.None));
+      GetVariableInfo(INITIALIZATION).Local = false;
+      CombinedOperator combinedOp = new CombinedOperator();
+      SequentialProcessor seq = new SequentialProcessor();
+      UniformRandomizer indexRandomizer = new UniformRandomizer();
+      indexRandomizer.Min = 0;
+      indexRandomizer.Max = 10;
+      indexRandomizer.GetVariableInfo("Value").ActualName = INDEX;
+      indexRandomizer.Name = "Index Randomizer";
+      NormalRandomizer weightRandomizer = new NormalRandomizer();
+      weightRandomizer.Mu = 1.0;
+      weightRandomizer.Sigma = 1.0;
+      weightRandomizer.GetVariableInfo("Value").ActualName = WEIGHT;
+      weightRandomizer.Name = "Weight Randomizer";
+      UniformRandomizer offsetRandomizer = new UniformRandomizer();
+      offsetRandomizer.Min = 0.0;
+      offsetRandomizer.Max = 1.0;
+      offsetRandomizer.GetVariableInfo("Value").ActualName = OFFSET;
+      offsetRandomizer.Name = "Offset Randomizer";
+
+      combinedOp.OperatorGraph.AddOperator(seq);
+      combinedOp.OperatorGraph.AddOperator(indexRandomizer);
+      combinedOp.OperatorGraph.AddOperator(weightRandomizer);
+      combinedOp.OperatorGraph.AddOperator(offsetRandomizer);
+      combinedOp.OperatorGraph.InitialOperator = seq;
+      seq.AddSubOperator(indexRandomizer);
+      seq.AddSubOperator(weightRandomizer);
+      seq.AddSubOperator(offsetRandomizer);
+      AddVariable(new HeuristicLab.Core.Variable(INITIALIZATION, combinedOp));
+    }
+
+    private void SetupManipulation() {
+      // manipulation operator
+      AddVariableInfo(new VariableInfo(MANIPULATION, "Manipulation operator for differentials", typeof(CombinedOperator), VariableKind.None));
+      GetVariableInfo(MANIPULATION).Local = false;
+      CombinedOperator combinedOp = new CombinedOperator();
+      SequentialProcessor seq = new SequentialProcessor();
+      UniformRandomizer indexRandomizer = new UniformRandomizer();
+      indexRandomizer.Min = 0;
+      indexRandomizer.Max = 10;
+      indexRandomizer.GetVariableInfo("Value").ActualName = INDEX;
+      indexRandomizer.Name = "Index Randomizer";
+      NormalRandomAdder weightRandomAdder = new NormalRandomAdder();
+      weightRandomAdder.Mu = 0.0;
+      weightRandomAdder.Sigma = 0.1;
+      weightRandomAdder.GetVariableInfo("Value").ActualName = WEIGHT;
+      weightRandomAdder.Name = "Weight Adder";
+      NormalRandomAdder offsetRandomAdder = new NormalRandomAdder();
+      offsetRandomAdder.Mu = 0.0;
+      offsetRandomAdder.Sigma = 1.0;
+      offsetRandomAdder.GetVariableInfo("Value").ActualName = OFFSET;
+      offsetRandomAdder.Name = "Offset Adder";
+
+      combinedOp.OperatorGraph.AddOperator(seq);
+      combinedOp.OperatorGraph.AddOperator(indexRandomizer);
+      combinedOp.OperatorGraph.AddOperator(weightRandomAdder);
+      combinedOp.OperatorGraph.AddOperator(offsetRandomAdder);
+      combinedOp.OperatorGraph.InitialOperator = seq;
+      seq.AddSubOperator(indexRandomizer);
+      seq.AddSubOperator(weightRandomAdder);
+      seq.AddSubOperator(offsetRandomAdder);
+      AddVariable(new HeuristicLab.Core.Variable(MANIPULATION, combinedOp));
     }
 
Index: trunk/sources/HeuristicLab.Functions/FunctionBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Functions/FunctionBase.cs	(revision 424)
+++ trunk/sources/HeuristicLab.Functions/FunctionBase.cs	(revision 425)
@@ -34,4 +34,7 @@
   /// </summary>
   public abstract class FunctionBase : OperatorBase, IFunction {
+    protected const string INITIALIZATION = "Initialization";
+    protected const string MANIPULATION = "Manipulation";
+
 
     public virtual double Apply(Dataset dataset, int sampleIndex, double[] args) {
Index: trunk/sources/HeuristicLab.Functions/HeuristicLab.Functions.csproj
===================================================================
--- trunk/sources/HeuristicLab.Functions/HeuristicLab.Functions.csproj	(revision 424)
+++ trunk/sources/HeuristicLab.Functions/HeuristicLab.Functions.csproj	(revision 425)
@@ -118,7 +118,15 @@
       <Name>HeuristicLab.Operators.Programmable</Name>
     </ProjectReference>
+    <ProjectReference Include="..\HeuristicLab.Operators\HeuristicLab.Operators.csproj">
+      <Project>{A9983BA2-B3B2-475E-8E2C-62050B71D1C5}</Project>
+      <Name>HeuristicLab.Operators</Name>
+    </ProjectReference>
     <ProjectReference Include="..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
       <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
       <Name>HeuristicLab.PluginInfrastructure</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\HeuristicLab.Random\HeuristicLab.Random.csproj">
+      <Project>{47019A74-F7F7-482E-83AA-D3F4F777E879}</Project>
+      <Name>HeuristicLab.Random</Name>
     </ProjectReference>
   </ItemGroup>
Index: trunk/sources/HeuristicLab.Functions/HeuristicLabFunctionsPlugin.cs
===================================================================
--- trunk/sources/HeuristicLab.Functions/HeuristicLabFunctionsPlugin.cs	(revision 424)
+++ trunk/sources/HeuristicLab.Functions/HeuristicLabFunctionsPlugin.cs	(revision 425)
@@ -32,5 +32,7 @@
   [Dependency(Dependency = "HeuristicLab.Data")]
   [Dependency(Dependency = "HeuristicLab.DataAnalysis")]
+  [Dependency(Dependency = "HeuristicLab.Operators")]
   [Dependency(Dependency = "HeuristicLab.Operators.Programmable")]
+  [Dependency(Dependency = "HeuristicLab.Random")]
   public class HeuristicLabFunctionsPlugin : PluginBase {
   }
Index: trunk/sources/HeuristicLab.Functions/Variable.cs
===================================================================
--- trunk/sources/HeuristicLab.Functions/Variable.cs	(revision 424)
+++ trunk/sources/HeuristicLab.Functions/Variable.cs	(revision 425)
@@ -28,4 +28,6 @@
 using HeuristicLab.Constraints;
 using HeuristicLab.DataAnalysis;
+using HeuristicLab.Random;
+using HeuristicLab.Operators;
 
 namespace HeuristicLab.Functions {
@@ -62,10 +64,81 @@
 
       ConstrainedIntData sampleOffset = new ConstrainedIntData();
-      // initialize a totally arbitrary default range for sampleoffset = [-10, 10]
-      sampleOffset.AddConstraint(new IntBoundedConstraint(0, 0));
+      // initialize a sample offset for static models
+      IntBoundedConstraint offsetConstraint = new IntBoundedConstraint(0, 0);
+      offsetConstraint.LowerBoundIncluded = true;
+      offsetConstraint.UpperBoundIncluded = true;
+      sampleOffset.AddConstraint(offsetConstraint);
       AddVariable(new HeuristicLab.Core.Variable(OFFSET, sampleOffset));
+
+      SetupInitialization();
+      SetupManipulation();
 
       // variable can't have suboperators
       AddConstraint(new NumberOfSubOperatorsConstraint(0, 0));
+    }
+
+    private void SetupInitialization() {
+      AddVariableInfo(new VariableInfo(INITIALIZATION, "Initialization operator for variables", typeof(CombinedOperator), VariableKind.None));
+      GetVariableInfo(INITIALIZATION).Local = false;
+      CombinedOperator combinedOp = new CombinedOperator();
+      SequentialProcessor seq = new SequentialProcessor();
+      UniformRandomizer indexRandomizer = new UniformRandomizer();
+      indexRandomizer.Min = 0;
+      indexRandomizer.Max = 10;
+      indexRandomizer.GetVariableInfo("Value").ActualName = INDEX;
+      indexRandomizer.Name = "Index Randomizer";
+      NormalRandomizer weightRandomizer = new NormalRandomizer();
+      weightRandomizer.Mu = 1.0;
+      weightRandomizer.Sigma = 1.0;
+      weightRandomizer.GetVariableInfo("Value").ActualName = WEIGHT;
+      weightRandomizer.Name = "Weight Randomizer";
+      UniformRandomizer offsetRandomizer = new UniformRandomizer();
+      offsetRandomizer.Min = 0.0;
+      offsetRandomizer.Max = 1.0;
+      offsetRandomizer.GetVariableInfo("Value").ActualName = OFFSET;
+      offsetRandomizer.Name = "Offset Randomizer";
+
+      combinedOp.OperatorGraph.AddOperator(seq);
+      combinedOp.OperatorGraph.AddOperator(indexRandomizer);
+      combinedOp.OperatorGraph.AddOperator(weightRandomizer);
+      combinedOp.OperatorGraph.AddOperator(offsetRandomizer);
+      combinedOp.OperatorGraph.InitialOperator = seq;
+      seq.AddSubOperator(indexRandomizer);
+      seq.AddSubOperator(weightRandomizer);
+      seq.AddSubOperator(offsetRandomizer);
+      AddVariable(new HeuristicLab.Core.Variable(INITIALIZATION, combinedOp));
+    }
+
+    private void SetupManipulation() {
+      // manipulation operator
+      AddVariableInfo(new VariableInfo(MANIPULATION, "Manipulation operator for variables", typeof(CombinedOperator), VariableKind.None));
+      GetVariableInfo(MANIPULATION).Local = false;
+      CombinedOperator combinedOp = new CombinedOperator();
+      SequentialProcessor seq = new SequentialProcessor();
+      UniformRandomizer indexRandomizer = new UniformRandomizer();
+      indexRandomizer.Min = 0;
+      indexRandomizer.Max = 10;
+      indexRandomizer.GetVariableInfo("Value").ActualName = INDEX;
+      indexRandomizer.Name = "Index Randomizer";
+      NormalRandomAdder weightRandomAdder = new NormalRandomAdder();
+      weightRandomAdder.Mu = 0.0;
+      weightRandomAdder.Sigma = 0.1;
+      weightRandomAdder.GetVariableInfo("Value").ActualName = WEIGHT;
+      weightRandomAdder.Name = "Weight Adder";
+      NormalRandomAdder offsetRandomAdder = new NormalRandomAdder();
+      offsetRandomAdder.Mu = 0.0;
+      offsetRandomAdder.Sigma = 1.0;
+      offsetRandomAdder.GetVariableInfo("Value").ActualName = OFFSET;
+      offsetRandomAdder.Name = "Offset Adder";
+
+      combinedOp.OperatorGraph.AddOperator(seq);
+      combinedOp.OperatorGraph.AddOperator(indexRandomizer);
+      combinedOp.OperatorGraph.AddOperator(weightRandomAdder);
+      combinedOp.OperatorGraph.AddOperator(offsetRandomAdder);
+      combinedOp.OperatorGraph.InitialOperator = seq;
+      seq.AddSubOperator(indexRandomizer);
+      seq.AddSubOperator(weightRandomAdder);
+      seq.AddSubOperator(offsetRandomAdder);
+      AddVariable(new HeuristicLab.Core.Variable(MANIPULATION, combinedOp));
     }
 
Index: trunk/sources/HeuristicLab.StructureIdentification/GPOperatorGroup.cs
===================================================================
--- trunk/sources/HeuristicLab.StructureIdentification/GPOperatorGroup.cs	(revision 424)
+++ trunk/sources/HeuristicLab.StructureIdentification/GPOperatorGroup.cs	(revision 425)
@@ -41,42 +41,42 @@
       var localVariableInfos = op.VariableInfos.Where(f => f.Local);
 
-      if(op.GetVariable(GPOperatorLibrary.MANIPULATION) == null) {
-        CombinedOperator manipulationOperator = new CombinedOperator();
-        SequentialProcessor manipulationSequence = new SequentialProcessor();
-        foreach(IVariableInfo variableInfo in localVariableInfos) {
-          IOperator manipulator = GetDefaultManipulationOperator(variableInfo);
-          if (manipulator != null) {
-            manipulationSequence.AddSubOperator(manipulator);
-          }
-        }
-        if(manipulationSequence.SubOperators.Count > 0) {
-          op.AddVariable(new Variable(GPOperatorLibrary.MANIPULATION, manipulationOperator));
-
-          manipulationOperator.OperatorGraph.AddOperator(manipulationSequence);
-          manipulationOperator.OperatorGraph.InitialOperator = manipulationSequence;
-          foreach(IOperator subOp in manipulationSequence.SubOperators) {
-            manipulationOperator.OperatorGraph.AddOperator(subOp);
-          }
-        }
-      }
-
-      if(op.GetVariable(GPOperatorLibrary.INITIALIZATION) == null) {
-        CombinedOperator initOperator = new CombinedOperator();
-        SequentialProcessor initSequence = new SequentialProcessor();
-        foreach(IVariableInfo variableInfo in localVariableInfos) {
-          IOperator initializer = GetDefaultInitOperator(variableInfo);
-          if (initializer != null) {
-            initSequence.AddSubOperator(initializer);
-          }
-        }
-        if(initSequence.SubOperators.Count > 0) {
-          op.AddVariable(new Variable(GPOperatorLibrary.INITIALIZATION, initOperator));
-          initOperator.OperatorGraph.AddOperator(initSequence);
-          initOperator.OperatorGraph.InitialOperator = initSequence;
-          foreach(IOperator subOp in initSequence.SubOperators) {
-            initOperator.OperatorGraph.AddOperator(subOp);
-          }
-        }
-      }
+      //if(op.GetVariable(GPOperatorLibrary.MANIPULATION) == null) {
+      //  CombinedOperator manipulationOperator = new CombinedOperator();
+      //  SequentialProcessor manipulationSequence = new SequentialProcessor();
+      //  foreach(IVariableInfo variableInfo in localVariableInfos) {
+      //    IOperator manipulator = GetDefaultManipulationOperator(variableInfo);
+      //    if (manipulator != null) {
+      //      manipulationSequence.AddSubOperator(manipulator);
+      //    }
+      //  }
+      //  if(manipulationSequence.SubOperators.Count > 0) {
+      //    op.AddVariable(new Variable(GPOperatorLibrary.MANIPULATION, manipulationOperator));
+
+      //    manipulationOperator.OperatorGraph.AddOperator(manipulationSequence);
+      //    manipulationOperator.OperatorGraph.InitialOperator = manipulationSequence;
+      //    foreach(IOperator subOp in manipulationSequence.SubOperators) {
+      //      manipulationOperator.OperatorGraph.AddOperator(subOp);
+      //    }
+      //  }
+      //}
+
+      //if(op.GetVariable(GPOperatorLibrary.INITIALIZATION) == null) {
+      //  CombinedOperator initOperator = new CombinedOperator();
+      //  SequentialProcessor initSequence = new SequentialProcessor();
+      //  foreach(IVariableInfo variableInfo in localVariableInfos) {
+      //    IOperator initializer = GetDefaultInitOperator(variableInfo);
+      //    if (initializer != null) {
+      //      initSequence.AddSubOperator(initializer);
+      //    }
+      //  }
+      //  if(initSequence.SubOperators.Count > 0) {
+      //    op.AddVariable(new Variable(GPOperatorLibrary.INITIALIZATION, initOperator));
+      //    initOperator.OperatorGraph.AddOperator(initSequence);
+      //    initOperator.OperatorGraph.InitialOperator = initSequence;
+      //    foreach(IOperator subOp in initSequence.SubOperators) {
+      //      initOperator.OperatorGraph.AddOperator(subOp);
+      //    }
+      //  }
+      //}
 
       // add a new typeid if necessary
@@ -97,8 +97,4 @@
         op.AddVariable(new Variable(GPOperatorLibrary.TICKETS, new DoubleData(1.0)));
       }
-
-      //RecalculateAllowedSuboperators();
-      //RecalculateMinimalTreeBounds();
-
       OnOperatorAdded(op);
     }
@@ -248,33 +244,33 @@
 
 
-    private IOperator GetDefaultManipulationOperator(IVariableInfo variableInfo) {
-      IOperator shaker;
-      if(variableInfo.DataType == typeof(ConstrainedDoubleData) ||
-        variableInfo.DataType == typeof(ConstrainedIntData) ||
-        variableInfo.DataType == typeof(DoubleData) ||
-        variableInfo.DataType == typeof(IntData)) {
-        shaker = new NormalRandomAdder();
-      } else {
-        return null;
-      }
-      shaker.GetVariableInfo("Value").ActualName = variableInfo.FormalName;
-      shaker.Name = variableInfo.FormalName + " manipulation";
-      return shaker;
-    }
-
-    private IOperator GetDefaultInitOperator(IVariableInfo variableInfo) {
-      IOperator shaker;
-      if(variableInfo.DataType == typeof(ConstrainedDoubleData) ||
-        variableInfo.DataType == typeof(ConstrainedIntData) ||
-        variableInfo.DataType == typeof(DoubleData) ||
-        variableInfo.DataType == typeof(IntData)) {
-        shaker = new UniformRandomizer();
-      } else {
-        return null;
-      }
-      shaker.GetVariableInfo("Value").ActualName = variableInfo.FormalName;
-      shaker.Name = variableInfo.FormalName + " initialization";
-      return shaker;
-    }
+    //private IOperator GetDefaultManipulationOperator(IVariableInfo variableInfo) {
+    //  IOperator shaker;
+    //  if(variableInfo.DataType == typeof(ConstrainedDoubleData) ||
+    //    variableInfo.DataType == typeof(ConstrainedIntData) ||
+    //    variableInfo.DataType == typeof(DoubleData) ||
+    //    variableInfo.DataType == typeof(IntData)) {
+    //    shaker = new NormalRandomAdder();
+    //  } else {
+    //    return null;
+    //  }
+    //  shaker.GetVariableInfo("Value").ActualName = variableInfo.FormalName;
+    //  shaker.Name = variableInfo.FormalName + " manipulation";
+    //  return shaker;
+    //}
+
+    //private IOperator GetDefaultInitOperator(IVariableInfo variableInfo) {
+    //  IOperator shaker;
+    //  if(variableInfo.DataType == typeof(ConstrainedDoubleData) ||
+    //    variableInfo.DataType == typeof(ConstrainedIntData) ||
+    //    variableInfo.DataType == typeof(DoubleData) ||
+    //    variableInfo.DataType == typeof(IntData)) {
+    //    shaker = new UniformRandomizer();
+    //  } else {
+    //    return null;
+    //  }
+    //  shaker.GetVariableInfo("Value").ActualName = variableInfo.FormalName;
+    //  shaker.Name = variableInfo.FormalName + " initialization";
+    //  return shaker;
+    //}
 
     public override void AddSubGroup(IOperatorGroup group) {
@@ -284,6 +280,4 @@
     public override void RemoveOperator(IOperator op) {
       base.RemoveOperator(op);
-      op.RemoveVariable(GPOperatorLibrary.MANIPULATION);
-      op.RemoveVariable(GPOperatorLibrary.INITIALIZATION);
       op.RemoveVariable(GPOperatorLibrary.TYPE_ID);
       op.RemoveVariable(GPOperatorLibrary.MIN_TREE_SIZE);
