Changeset 12706 for stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars

Timestamp:

07/10/15 12:02:20 (9 years ago)

Author:

mkommend

Message:

#2320: Merged r12422, r12423, r12424, r12480, r12481 and r12482 into stable.

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding (modified) (1 prop)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/EmptySymbolicExpressionTreeGrammar.cs (modified) (3 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SimpleSymbolicExpressionGrammar.cs (copied) (copied from trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SimpleSymbolicExpressionGrammar.cs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammar.cs (modified) (4 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammarBase.cs (modified) (13 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionTreeGrammar.cs (modified) (3 diffs)

stable/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
   }

stable/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;
 

stable/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);
@@ -308 +316 @@
     }
     public virtual IEnumerable<ISymbol> AllowedSymbols {
-      get { foreach (var s in Symbols) if (s.Enabled) yield return s; }
+      get { return Symbols.Where(s => s.Enabled); }
     }
     public virtual bool ContainsSymbol(ISymbol symbol) {
@@ -518 +526 @@
       if (suppressEvents) return;
       var handler = Changed;
-      if (handler != null) Changed(this, EventArgs.Empty);
+      if (handler != null) handler(this, EventArgs.Empty);
     }
   }

stable/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);
-    }
-
   }
 }