Changeset 12353 for branches/SymbolicExpressionTreeEncoding

Timestamp:

04/28/15 17:23:14 (10 years ago)

Author:

mkommend

Message:

#2320: Adapted grammars for the new encoding.

Location:

branches/SymbolicExpressionTreeEncoding

Files:

• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/EmptySymbolicExpressionTreeGrammar.cs (modified) (3 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammar.cs (modified) (4 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammarBase.cs (modified) (11 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionTreeGrammar.cs (modified) (3 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammar.cs (modified) (1 diff)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammarBase.cs (modified) (2 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeGrammar.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/MultiSymbolicDataAnalysisExpressionCrossover.cs (modified) (2 diffs)

branches/SymbolicExpressionTreeEncoding/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/EmptySymbolicExpressionTreeGrammar.cs

@@ -37 +37 @@
 
     [StorableConstructor]
-    private EmptySymbolicExpressionTreeGrammar(bool deserializing) : base(deserializing) {}
+    private EmptySymbolicExpressionTreeGrammar(bool deserializing) : base(deserializing) { }
     internal EmptySymbolicExpressionTreeGrammar(ISymbolicExpressionGrammar grammar)
       : base() {
@@ -70 +70 @@
     }
 
-    IEnumerable<ISymbol> ISymbolicExpressionGrammarBase.GetAllowedChildSymbols(ISymbol parent) {
+    public IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent) {
       return grammar.GetAllowedChildSymbols(parent);
     }
 
-    IEnumerable<ISymbol> ISymbolicExpressionGrammarBase.GetAllowedChildSymbols(ISymbol parent, int argumentIndex) {
+    public IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent, int argumentIndex) {
       return grammar.GetAllowedChildSymbols(parent, argumentIndex);
     }
@@ -85 +85 @@
     }
 
-    int ISymbolicExpressionGrammarBase.GetMinimumExpressionDepth(ISymbol symbol) {
+    public int GetMinimumExpressionDepth(ISymbol symbol) {
       return grammar.GetMinimumExpressionDepth(symbol);
     }
-    int ISymbolicExpressionGrammarBase.GetMaximumExpressionDepth(ISymbol symbol) {
+    public int GetMaximumExpressionDepth(ISymbol symbol) {
       return grammar.GetMaximumExpressionDepth(symbol);
     }
-    int ISymbolicExpressionGrammarBase.GetMinimumExpressionLength(ISymbol symbol) {
+    public int GetMinimumExpressionLength(ISymbol symbol) {
       return grammar.GetMinimumExpressionLength(symbol);
     }
-    int ISymbolicExpressionGrammarBase.GetMaximumExpressionLength(ISymbol symbol, int maxDepth) {
+    public int GetMaximumExpressionLength(ISymbol symbol, int maxDepth) {
       return grammar.GetMaximumExpressionLength(symbol, maxDepth);
     }
 
+    public void AddSymbol(ISymbol symbol) { throw new NotSupportedException(); }
+    public void RemoveSymbol(ISymbol symbol) { throw new NotSupportedException(); }
+    public void AddAllowedChildSymbol(ISymbol parent, ISymbol child) { throw new NotSupportedException(); }
+    public void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) { throw new NotSupportedException(); }
+    public void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) { throw new NotSupportedException(); }
+    public void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) { throw new NotSupportedException(); }
+    public void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) { throw new NotSupportedException(); }
+
 
     #region ISymbolicExpressionTreeGrammar Members
-    IEnumerable<ISymbol> ISymbolicExpressionTreeGrammar.ModifyableSymbols {
+    public IEnumerable<ISymbol> ModifyableSymbols {
       get { return Enumerable.Empty<ISymbol>(); }
     }
 
-    bool ISymbolicExpressionTreeGrammar.IsModifyableSymbol(ISymbol symbol) {
+    public bool IsModifyableSymbol(ISymbol symbol) {
       return false;
     }
 
-    void ISymbolicExpressionTreeGrammar.AddSymbol(ISymbol symbol) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.RemoveSymbol(ISymbol symbol) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
-      throw new NotSupportedException();
-    }
-    
-    #pragma warning disable 0067 //disable usage warning
+#pragma warning disable 0067 //disable usage warning
     public event EventHandler Changed;
-    #pragma warning restore 0067
+#pragma warning restore 0067
     #endregion
   }

branches/SymbolicExpressionTreeEncoding/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammar.cs

@@ -177 +177 @@
     }
 
-    protected override sealed void AddSymbol(ISymbol symbol) {
+    public override sealed void AddSymbol(ISymbol symbol) {
+      if (ReadOnly) throw new InvalidOperationException();
       base.AddSymbol(symbol);
       RegisterSymbolEvents(symbol);
       OnChanged();
     }
-    protected override sealed void RemoveSymbol(ISymbol symbol) {
+    public override sealed void RemoveSymbol(ISymbol symbol) {
+      if (ReadOnly) throw new InvalidOperationException();
       DeregisterSymbolEvents(symbol);
       base.RemoveSymbol(symbol);
@@ -204 +206 @@
     #endregion
 
-    #region ISymbolicExpressionGrammar methods
-    void ISymbolicExpressionGrammar.AddSymbol(ISymbol symbol) {
-      if (ReadOnly) throw new InvalidOperationException();
-      AddSymbol(symbol);
-    }
-    void ISymbolicExpressionGrammar.RemoveSymbol(ISymbol symbol) {
-      if (ReadOnly) throw new InvalidOperationException();
-      RemoveSymbol(symbol);
-    }
-
-    void ISymbolicExpressionGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
+    public sealed override void AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
       if (ReadOnly) throw new InvalidOperationException();
       base.AddAllowedChildSymbol(parent, child);
     }
-    void ISymbolicExpressionGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+    public sealed override void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
       if (ReadOnly) throw new InvalidOperationException();
       base.AddAllowedChildSymbol(parent, child, argumentIndex);
     }
-    void ISymbolicExpressionGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
+    public sealed override void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
       if (ReadOnly) throw new InvalidOperationException();
       base.RemoveAllowedChildSymbol(parent, child);
     }
-    void ISymbolicExpressionGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+    public sealed override void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
       if (ReadOnly) throw new InvalidOperationException();
       base.RemoveAllowedChildSymbol(parent, child, argumentIndex);
     }
 
-    void ISymbolicExpressionGrammar.SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
+    public sealed override void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
       if (ReadOnly) throw new InvalidOperationException();
       base.SetSubtreeCount(symbol, minimumSubtreeCount, maximumSubtreeCount);
@@ -237 +229 @@
 
     private bool suppressEvents = false;
-    void ISymbolicExpressionGrammar.StartGrammarManipulation() {
+    public void StartGrammarManipulation() {
       suppressEvents = true;
     }
-    void ISymbolicExpressionGrammar.FinishedGrammarManipulation() {
+    public void FinishedGrammarManipulation() {
       suppressEvents = false;
       OnChanged();
     }
 
-    protected override void OnChanged() {
+    protected sealed override void OnChanged() {
       if (suppressEvents) return;
       base.OnChanged();
     }
-    #endregion
 
     #region symbol events
@@ -305 +296 @@
     private void Symbol_NameChanged(object sender, EventArgs e) {
       ISymbol symbol = (ISymbol)sender;
-      string oldName = symbols.Where(x => x.Value == symbol).First().Key;
+      string oldName = symbols.First(x => x.Value == symbol).Key;
       string newName = symbol.Name;
 

branches/SymbolicExpressionTreeEncoding/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammarBase.cs

@@ -41 +41 @@
     private IEnumerable<ISymbol> StorableSymbols {
       get { return symbols.Values.ToArray(); }
-      set { symbols = value.ToDictionary(sym => sym.Name); }
+      set { foreach (var s in value) symbols.Add(s.Name, s); }
     }
 
@@ -47 +47 @@
     private IEnumerable<KeyValuePair<ISymbol, Tuple<int, int>>> StorableSymbolSubtreeCount {
       get { return symbolSubtreeCount.Select(x => new KeyValuePair<ISymbol, Tuple<int, int>>(GetSymbol(x.Key), x.Value)).ToArray(); }
-      set { symbolSubtreeCount = value.ToDictionary(x => x.Key.Name, x => x.Value); }
+      set { foreach (var pair in value) symbolSubtreeCount.Add(pair.Key.Name, pair.Value); }
     }
 
@@ -53 +53 @@
     private IEnumerable<KeyValuePair<ISymbol, IEnumerable<ISymbol>>> StorableAllowedChildSymbols {
       get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(GetSymbol).ToArray())).ToArray(); }
-      set { allowedChildSymbols = value.ToDictionary(x => x.Key.Name, x => x.Value.Select(y => y.Name).ToList()); }
+      set { foreach (var pair in value) allowedChildSymbols.Add(pair.Key.Name, pair.Value.Select(y => y.Name).ToList()); }
     }
 
     [Storable(Name = "AllowedChildSymbolsPerIndex")]
     private IEnumerable<KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>> StorableAllowedChildSymbolsPerIndex {
-      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create<ISymbol, int>(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(y => GetSymbol(y)).ToArray())).ToArray(); }
-      set { allowedChildSymbolsPerIndex = value.ToDictionary(x => Tuple.Create(x.Key.Item1.Name, x.Key.Item2), x => x.Value.Select(y => y.Name).ToList()); }
+      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(GetSymbol).ToArray())).ToArray(); }
+      set {
+        foreach (var pair in value)
+          allowedChildSymbolsPerIndex.Add(Tuple.Create(pair.Key.Item1.Name, pair.Key.Item2), pair.Value.Select(y => y.Name).ToList());
+      }
     }
     #endregion
 
     private bool suppressEvents;
-    protected Dictionary<string, ISymbol> symbols;
-    protected Dictionary<string, Tuple<int, int>> symbolSubtreeCount;
-    protected Dictionary<string, List<string>> allowedChildSymbols;
-    protected Dictionary<Tuple<string, int>, List<string>> allowedChildSymbolsPerIndex;
+    protected readonly Dictionary<string, ISymbol> symbols;
+    protected readonly Dictionary<string, Tuple<int, int>> symbolSubtreeCount;
+    protected readonly Dictionary<string, List<string>> allowedChildSymbols;
+    protected readonly Dictionary<Tuple<string, int>, List<string>> allowedChildSymbolsPerIndex;
 
     public override bool CanChangeName {
@@ -87 +90 @@
       cachedIsAllowedChildSymbolIndex = new Dictionary<Tuple<string, string, int>, bool>();
 
+      symbols = new Dictionary<string, ISymbol>();
+      symbolSubtreeCount = new Dictionary<string, Tuple<int, int>>();
+      allowedChildSymbols = new Dictionary<string, List<string>>();
+      allowedChildSymbolsPerIndex = new Dictionary<Tuple<string, int>, List<string>>();
+
       suppressEvents = false;
     }
@@ -133 +141 @@
 
     #region protected grammar manipulation methods
-    protected virtual void AddSymbol(ISymbol symbol) {
+    public virtual void AddSymbol(ISymbol symbol) {
       if (ContainsSymbol(symbol)) throw new ArgumentException("Symbol " + symbol + " is already defined.");
       foreach (var s in symbol.Flatten()) {
@@ -143 +151 @@
     }
 
-    protected virtual void RemoveSymbol(ISymbol symbol) {
+    public virtual void RemoveSymbol(ISymbol symbol) {
       foreach (var s in symbol.Flatten()) {
         symbols.Remove(s.Name);
@@ -175 +183 @@
     }
 
-    protected void AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
+    public virtual void AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
       bool changed = false;
 
@@ -204 +212 @@
     }
 
-    protected void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+    public virtual void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
       bool changed = false;
 
@@ -238 +246 @@
     }
 
-    protected void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
+    public virtual void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
       bool changed = false;
       List<string> childSymbols;
@@ -257 +265 @@
     }
 
-    protected void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+    public virtual void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
       bool changed = false;
 
@@ -282 +290 @@
     }
 
-    protected void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
+    public virtual void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
       var symbols = symbol.Flatten().Where(s => !(s is GroupSymbol));
       if (symbols.Any(s => s.MinimumArity > minimumSubtreeCount)) throw new ArgumentException("Invalid minimum subtree count " + minimumSubtreeCount + " for " + symbol);

branches/SymbolicExpressionTreeEncoding/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionTreeGrammar.cs

@@ -55 +55 @@
       }
     }
-    public override IEnumerable<ISymbol> AllowedSymbols {
-      get { return base.AllowedSymbols; }
-    }
     public IEnumerable<ISymbol> ModifyableSymbols {
       get { return base.symbols.Values; }
@@ -76 +73 @@
     }
 
-    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      return grammar.IsAllowedChildSymbol(parent, child) || base.IsAllowedChildSymbol(parent, child);
-    }
-    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      return grammar.IsAllowedChildSymbol(parent, child, argumentIndex) || base.IsAllowedChildSymbol(parent, child, argumentIndex);
+    public override void RemoveSymbol(ISymbol symbol) {
+      if (!IsModifyableSymbol(symbol)) throw new InvalidOperationException();
+      base.RemoveSymbol(symbol);
     }
 
@@ -91 +86 @@
       return base.GetMaximumSubtreeCount(symbol);
     }
-
-    void ISymbolicExpressionTreeGrammar.AddSymbol(ISymbol symbol) {
-      base.AddSymbol(symbol);
-    }
-    void ISymbolicExpressionTreeGrammar.RemoveSymbol(ISymbol symbol) {
-      if (!IsModifyableSymbol(symbol)) throw new InvalidOperationException();
-      base.RemoveSymbol(symbol);
-    }
-    void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      base.AddAllowedChildSymbol(parent, child);
-    }
-    void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      base.AddAllowedChildSymbol(parent, child, argumentIndex);
-    }
-    void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      base.RemoveAllowedChildSymbol(parent, child);
-    }
-    void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      base.RemoveAllowedChildSymbol(parent, child, argumentIndex);
-    }
-
-    void ISymbolicExpressionTreeGrammar.SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
+    public override void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
       if (!IsModifyableSymbol(symbol)) throw new InvalidOperationException();
       base.SetSubtreeCount(symbol, minimumSubtreeCount, maximumSubtreeCount);
     }
 
-    int ISymbolicExpressionGrammarBase.GetMinimumExpressionDepth(ISymbol symbol) {
-      if (symbols.Count == 0) return grammar.GetMinimumExpressionDepth(symbol);
-      else return base.GetMinimumExpressionDepth(symbol);
+    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child) {
+      return grammar.IsAllowedChildSymbol(parent, child) || base.IsAllowedChildSymbol(parent, child);
     }
-    int ISymbolicExpressionGrammarBase.GetMaximumExpressionDepth(ISymbol symbol) {
-      if (symbols.Count == 0) return grammar.GetMaximumExpressionDepth(symbol);
-      else return base.GetMaximumExpressionDepth(symbol);
+    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+      return grammar.IsAllowedChildSymbol(parent, child, argumentIndex) || base.IsAllowedChildSymbol(parent, child, argumentIndex);
     }
-    int ISymbolicExpressionGrammarBase.GetMinimumExpressionLength(ISymbol symbol) {
-      if (symbols.Count == 0) return grammar.GetMinimumExpressionLength(symbol);
-      else return base.GetMinimumExpressionLength(symbol);
-    }
-    int ISymbolicExpressionGrammarBase.GetMaximumExpressionLength(ISymbol symbol, int maxDepth) {
-      if (symbols.Count == 0) return grammar.GetMaximumExpressionLength(symbol, maxDepth);
-      else return base.GetMaximumExpressionLength(symbol, maxDepth);
-    }
-
   }
 }

branches/SymbolicExpressionTreeEncoding/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammar.cs

@@ -36 +36 @@
     event EventHandler ReadOnlyChanged;
 
-    void AddSymbol(ISymbol symbol);
-    void RemoveSymbol(ISymbol symbol);
-
-    void AddAllowedChildSymbol(ISymbol parent, ISymbol child);
-    void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
-    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child);
-    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
-
-    void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount);
-
     void StartGrammarManipulation();
     void FinishedGrammarManipulation();

branches/SymbolicExpressionTreeEncoding/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammarBase.cs

@@ -27 +27 @@
   public interface ISymbolicExpressionGrammarBase : INamedItem {
     IEnumerable<ISymbol> Symbols { get; }
+    IEnumerable<ISymbol> AllowedSymbols { get; }
+
+    bool ContainsSymbol(ISymbol symbol);
     ISymbol GetSymbol(string symbolName);
-    IEnumerable<ISymbol> AllowedSymbols { get; }
-    bool ContainsSymbol(ISymbol symbol);
+
+    void AddSymbol(ISymbol symbol);
+    void RemoveSymbol(ISymbol symbol);
 
     bool IsAllowedChildSymbol(ISymbol parent, ISymbol child);
@@ -36 +40 @@
     IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent, int argumentIndex);
 
+    void AddAllowedChildSymbol(ISymbol parent, ISymbol child);
+    void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
+    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child);
+    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
+
+
     int GetMinimumSubtreeCount(ISymbol symbol);
     int GetMaximumSubtreeCount(ISymbol symbol);
+    void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount);
 
     int GetMinimumExpressionDepth(ISymbol start);

branches/SymbolicExpressionTreeEncoding/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeGrammar.cs

@@ -23 +23 @@
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
   public interface ISymbolicExpressionTreeGrammar : ISymbolicExpressionGrammarBase {
-
     IEnumerable<ISymbol> ModifyableSymbols { get; }
     bool IsModifyableSymbol(ISymbol symbol);
-    void AddSymbol(ISymbol symbol);
-    void RemoveSymbol(ISymbol symbol);
-
-    void AddAllowedChildSymbol(ISymbol parent, ISymbol child);
-    void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
-    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child);
-    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
-
-    void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount);
   }
 }

branches/SymbolicExpressionTreeEncoding/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/MultiSymbolicDataAnalysisExpressionCrossover.cs

@@ -35 +35 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [Item("MultiSymbolicDataAnalysisExpressionCrossover", "Randomly selects and applies one of its crossovers every time it is called.")]
+  [StorableClass]
   public class MultiSymbolicDataAnalysisExpressionCrossover<T> : StochasticMultiBranch<ISymbolicExpressionTreeCrossover>,
     ISymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData {
@@ -113 +114 @@
     }
 
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code, remove with 3.4
+      if (!Parameters.ContainsKey(SymbolicExpressionTreeParameterName))
+        Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree on which the operator should be applied."));
+      #endregion
+    }
+
     private void InitializeOperators() {
       var list = ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeCrossover>().ToList();