Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/SymbolicExpressionGrammar/SymbolValueConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/SymbolicExpressionGrammar/SymbolValueConfiguration.cs	(revision 6023)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/SymbolicExpressionGrammar/SymbolValueConfiguration.cs	(revision 6023)
@@ -0,0 +1,113 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class SymbolValueConfiguration : ParameterizedValueConfiguration {
+
+    #region Constructors and Cloning
+    [StorableConstructor]
+    protected SymbolValueConfiguration(bool deserializing) : base(deserializing) { }
+    public SymbolValueConfiguration() : base() { }
+    public SymbolValueConfiguration(Symbol symbol)
+      : base() {
+      this.IsOptimizable = true;
+      this.Optimize = false;
+      this.Name = symbol.Name;
+      this.actualValue = new ConstrainedValue(symbol, symbol.GetType(), new ItemSet<IItem> { symbol }, false);
+    }
+    protected SymbolValueConfiguration(SymbolValueConfiguration original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolValueConfiguration(this, cloner);
+    }
+    #endregion
+
+    protected override void PopulateParameterConfigurations(IItem item, bool discoverValidValues) {
+      this.ClearParameterConfigurations();
+
+      var symbol = (Symbol)item;
+
+      var initialFrequencyValueConfigurations = new List<IValueConfiguration>();
+      initialFrequencyValueConfigurations.Add(new RangeValueConfiguration(new DoubleValue(0), typeof(DoubleValue)));
+      initialFrequencyValueConfigurations.Add(new RangeValueConfiguration(new DoubleValue(1), typeof(DoubleValue)));
+      var initialFrequencyParameterConfiguration = new ParameterConfiguration("InitialFrequency", typeof(Symbol), new DoubleValue(symbol.InitialFrequency), initialFrequencyValueConfigurations);
+      this.parameterConfigurations.Add(initialFrequencyParameterConfiguration);
+
+      var constant = symbol as Constant;
+      if (constant != null) {
+        var minValueParameterConfiguration = new ParameterConfiguration("MinValue", typeof(DoubleValue), new DoubleValue(constant.MinValue));
+        var maxValueParameterConfiguration = new ParameterConfiguration("MaxValue", typeof(DoubleValue), new DoubleValue(constant.MaxValue));
+        var manipulatorMuParameterConfiguration = new ParameterConfiguration("ManipulatorMu", typeof(DoubleValue), new DoubleValue(constant.ManipulatorMu));
+        var manipulatorSigmaParameterConfiguration = new ParameterConfiguration("ManipulatorSigma", typeof(DoubleValue), new DoubleValue(constant.ManipulatorSigma));
+        var multiplicativeManipulatorSigmaParameterConfiguration = new ParameterConfiguration("MultiplicativeManipulatorSigma", typeof(DoubleValue), new DoubleValue(constant.MultiplicativeManipulatorSigma));
+
+        this.parameterConfigurations.Add(minValueParameterConfiguration);
+        this.parameterConfigurations.Add(maxValueParameterConfiguration);
+        this.parameterConfigurations.Add(manipulatorMuParameterConfiguration);
+        this.parameterConfigurations.Add(manipulatorSigmaParameterConfiguration);
+        this.parameterConfigurations.Add(multiplicativeManipulatorSigmaParameterConfiguration);
+      }
+
+      var variable = symbol as HeuristicLab.Problems.DataAnalysis.Symbolic.Variable;
+      if (variable != null) {
+        var weightMuParameterConfiguration = new ParameterConfiguration("WeightMu", typeof(DoubleValue), new DoubleValue(variable.WeightMu));
+        var weightSigmaParameterConfiguration = new ParameterConfiguration("WeightSigma", typeof(DoubleValue), new DoubleValue(variable.WeightSigma));
+        var weightManipulatorMuParameterConfiguration = new ParameterConfiguration("WeightManipulatorMu", typeof(DoubleValue), new DoubleValue(variable.WeightManipulatorMu));
+        var weightManipulatorSigmaParameterConfiguration = new ParameterConfiguration("WeightManipulatorSigma", typeof(DoubleValue), new DoubleValue(variable.WeightManipulatorSigma));
+        var multiplicativeWeightManipulatorSigmaParameterConfiguration = new ParameterConfiguration("MultiplicativeWeightManipulatorSigma", typeof(DoubleValue), new DoubleValue(variable.MultiplicativeWeightManipulatorSigma));
+
+        this.parameterConfigurations.Add(weightMuParameterConfiguration);
+        this.parameterConfigurations.Add(weightSigmaParameterConfiguration);
+        this.parameterConfigurations.Add(weightManipulatorMuParameterConfiguration);
+        this.parameterConfigurations.Add(weightManipulatorSigmaParameterConfiguration);
+        this.parameterConfigurations.Add(multiplicativeWeightManipulatorSigmaParameterConfiguration);
+      }
+    }
+
+    public virtual void Parameterize(Symbol symbol) {
+      symbol.InitialFrequency = GetDoubleValue("InitialFrequency");
+      
+      var constant = symbol as Constant;
+      if (constant != null) {
+        constant.MinValue = GetDoubleValue("MinValue");
+        constant.MaxValue = GetDoubleValue("MaxValue");
+        constant.ManipulatorMu = GetDoubleValue("ManipulatorMu");
+        constant.ManipulatorSigma = GetDoubleValue("ManipulatorSigma");
+        constant.MultiplicativeManipulatorSigma = GetDoubleValue("MultiplicativeManipulatorSigma");
+      }
+      
+      var variable = symbol as HeuristicLab.Problems.DataAnalysis.Symbolic.Variable;
+      if (variable != null) {
+        variable.WeightMu = GetDoubleValue("WeightMu");
+        variable.WeightSigma = GetDoubleValue("WeightSigma");
+        variable.WeightManipulatorMu = GetDoubleValue("WeightManipulatorMu");
+        variable.WeightManipulatorSigma = GetDoubleValue("WeightManipulatorSigma");
+        variable.MultiplicativeWeightManipulatorSigma = GetDoubleValue("MultiplicativeWeightManipulatorSigma");
+      }
+    }
+
+    private double GetDoubleValue(string name) {
+      return ((DoubleValue)ParameterConfigurations.Single(x => x.Name == name).ActualValue.Value).Value;
+    }
+
+    public override string ToString() {
+      return string.Format("{0}: {1}", this.Name, parameterConfigurations.Single(pc => pc.Name == "InitialFrequency").ActualValue.Value);
+    }
+
+    public override void Mutate(IRandom random, MutateDelegate mutate, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
+      base.Mutate(random, mutate, intValueManipulator, doubleValueManipulator);
+    }
+
+    public override void Cross(IRandom random, IOptimizable other, CrossDelegate cross, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover) {
+      base.Cross(random, other, cross, intValueCrossover, doubleValueCrossover);
+    }
+  }
+}
Index: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/SymbolicExpressionGrammar/SymbolicExpressionGrammarValueConfiguration.cs
===================================================================
--- branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/SymbolicExpressionGrammar/SymbolicExpressionGrammarValueConfiguration.cs	(revision 6023)
+++ branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/SymbolicExpressionGrammar/SymbolicExpressionGrammarValueConfiguration.cs	(revision 6023)
@@ -0,0 +1,55 @@
+﻿using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.MetaOptimization {
+  [StorableClass]
+  public class SymbolicExpressionGrammarValueConfiguration : ParameterizedValueConfiguration {
+
+    #region Constructors and Cloning
+    [StorableConstructor]
+    protected SymbolicExpressionGrammarValueConfiguration(bool deserializing) : base(deserializing) { }
+    public SymbolicExpressionGrammarValueConfiguration() : base() { }
+    public SymbolicExpressionGrammarValueConfiguration(ISymbolicExpressionGrammar grammar) {
+      this.IsOptimizable = true;
+      this.ActualValue = new ConstrainedValue(grammar, grammar.GetType(), new ItemSet<IItem> { grammar }, false);
+    }
+    protected SymbolicExpressionGrammarValueConfiguration(SymbolicExpressionGrammarValueConfiguration original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionGrammarValueConfiguration(this, cloner);
+    }
+    #endregion
+
+    protected override void PopulateParameterConfigurations(IItem item, bool discoverValidValues) {
+      var grammar = (ISymbolicExpressionGrammar)item;
+      foreach (Symbol symbol in grammar.Symbols) {
+        var pc = new SingleValuedParameterConfiguration(symbol.Name, new SymbolValueConfiguration(symbol));
+        SetOptimizeIfOnlyOneValueConfiguration(pc);
+        this.parameterConfigurations.Add(pc);
+      }
+    }
+
+    public virtual void Parameterize(ISymbolicExpressionGrammar grammar) {
+      foreach (Symbol symbol in grammar.Symbols) {
+        ((SymbolValueConfiguration)this.parameterConfigurations.Single(pc => pc.Name == symbol.Name).ValueConfigurations.First()).Parameterize(symbol);
+      }
+    }
+
+    /// <summary>
+    /// If only 1 parameter exists (usually this is InitialFrequency), then set it to Optimize=true,
+    /// because this is what the user usually wants to do. avoids additional click.
+    /// </summary>
+    private static void SetOptimizeIfOnlyOneValueConfiguration(SingleValuedParameterConfiguration pc) {
+      var vc = pc.ValueConfigurations[0] as ParameterizedValueConfiguration;
+      if (vc != null) {
+        if (vc.ParameterConfigurations.Count == 1) {
+          vc.ParameterConfigurations.Single().Optimize = true;
+        }
+      }
+    }
+  }
+}
