Changeset 6233 for trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding

Timestamp:

05/19/11 13:52:12 (13 years ago)

Author:

mkommend

Message:

#1532:

• Enabled renaming of symbols
• Fixed cloning of grammers
• Added readonly attribute in grammars to lock grammars during the algorithm run
• Removed useless clone method in cloner
• Changed CheckedItemCollectionViews to enable scrolling during the locked state

Location:

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4

Files:

• ArchitectureManipulators/SubroutineDuplicater.cs (modified) (2 diffs)
• Creators/ProbabilisticTreeCreator.cs (modified) (6 diffs)
• Creators/SymbolicExpressionTreeCreator.cs (modified) (2 diffs)
• Interfaces/ISymbolicExpressionGrammar.cs (modified) (2 diffs)
• SymbolicExpressionGrammar.cs (modified) (4 diffs)
• SymbolicExpressionGrammarBase.cs (modified) (6 diffs)
• SymbolicExpressionTreeGrammar.cs (modified) (1 diff)
• SymbolicExpressionTreeTerminalNode.cs (modified) (1 diff)
• SymbolicExpressionTreeTopLevelNode.cs (modified) (1 diff)
• Symbols/Argument.cs (modified) (1 diff)
• Symbols/InvokeFunction.cs (modified) (3 diffs)
• Symbols/Symbol.cs (modified) (3 diffs)

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs

@@ -83 +83 @@
           subtree.Grammar.SetSubtreeCount(invokeSymbol, duplicatedDefunBranch.NumberOfArguments, duplicatedDefunBranch.NumberOfArguments);
 
-          foreach (Symbol symbol in subtree.Grammar.Symbols) {
+          foreach (ISymbol symbol in subtree.Grammar.Symbols) {
             if (subtree.Grammar.IsAllowedChildSymbol(symbol, matchingInvokeSymbol))
               subtree.Grammar.AddAllowedChildSymbol(symbol, invokeSymbol);
@@ -93 +93 @@
           }
 
-          foreach (Symbol symbol in subtree.Grammar.GetAllowedChildSymbols(matchingInvokeSymbol))
+          foreach (ISymbol symbol in subtree.Grammar.GetAllowedChildSymbols(matchingInvokeSymbol))
             if (symbol != invokeSymbol) //avoid duplicate entry invokesymbol / invokesymbol
               subtree.Grammar.AddAllowedChildSymbol(invokeSymbol, symbol);
           for (int i = 0; i < subtree.Grammar.GetMaximumSubtreeCount(matchingInvokeSymbol); i++) {
-            foreach (Symbol symbol in subtree.Grammar.GetAllowedChildSymbols(matchingInvokeSymbol, i).Except(subtree.Grammar.GetAllowedChildSymbols(matchingInvokeSymbol)))
+            foreach (ISymbol symbol in subtree.Grammar.GetAllowedChildSymbols(matchingInvokeSymbol, i).Except(subtree.Grammar.GetAllowedChildSymbols(matchingInvokeSymbol)))
               subtree.Grammar.AddAllowedChildSymbol(invokeSymbol, symbol, i);
           }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs

@@ -38 +38 @@
     private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
     private const string SymbolicExpressionTreeGrammarParameterName = "SymbolicExpressionTreeGrammar";
+    private const string ClonedSymbolicExpressionTreeGrammarParameterName = "ClonedSymbolicExpressionTreeGrammar";
     #region Parameter Properties
     public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
@@ -47 +48 @@
     public IValueLookupParameter<ISymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter {
       get { return (IValueLookupParameter<ISymbolicExpressionGrammar>)Parameters[SymbolicExpressionTreeGrammarParameterName]; }
+    }
+    public ILookupParameter<ISymbolicExpressionGrammar> ClonedSymbolicExpressionTreeGrammarParameter {
+      get { return (ILookupParameter<ISymbolicExpressionGrammar>)Parameters[ClonedSymbolicExpressionTreeGrammarParameterName]; }
     }
     #endregion
@@ -57 +61 @@
     }
     public ISymbolicExpressionGrammar SymbolicExpressionTreeGrammar {
-      get { return SymbolicExpressionTreeGrammarParameter.ActualValue; }
+      get { return ClonedSymbolicExpressionTreeGrammarParameter.ActualValue; }
     }
     #endregion
@@ -69 +73 @@
       Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
       Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName, "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionGrammar>(ClonedSymbolicExpressionTreeGrammarParameterName, "An immutable clone of the concrete grammar that is actually used to create and manipulate trees."));
     }
 
@@ -74 +79 @@
       return new ProbabilisticTreeCreator(this, cloner);
     }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ClonedSymbolicExpressionTreeGrammarParameterName))
+        Parameters.Add(new LookupParameter<ISymbolicExpressionGrammar>(ClonedSymbolicExpressionTreeGrammarParameterName, "An immutable clone of the concrete grammar that is actually used to create and manipulate trees."));
+    }
+
+    public override IOperation Apply() {
+      if (ClonedSymbolicExpressionTreeGrammarParameter.ActualValue == null) {
+        SymbolicExpressionTreeGrammarParameter.ActualValue.ReadOnly = true;
+        IScope globalScope = ExecutionContext.Scope;
+        while (globalScope.Parent != null)
+          globalScope = globalScope.Parent;
+
+        globalScope.Variables.Add(new Variable(ClonedSymbolicExpressionTreeGrammarParameterName, (ISymbolicExpressionGrammar)SymbolicExpressionTreeGrammarParameter.ActualValue.Clone()));
+      }
+      return base.Apply();
+    }
 
     protected override ISymbolicExpressionTree Create(IRandom random) {
       return Create(random, SymbolicExpressionTreeGrammar, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value);
-
     }
 
@@ -165 +186 @@
                                 select s)
                                .ToList();
+          if (allowedSymbols.Count == 0) return false;
           var weights = allowedSymbols.Select(x => x.InitialFrequency).ToList();
           var selectedSymbol = allowedSymbols.SelectRandom(weights, random);

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/SymbolicExpressionTreeCreator.cs

@@ -22 +22 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -55 +54 @@
     }
 
-    public sealed override IOperation Apply() {
+    public override IOperation Apply() {
       SymbolicExpressionTree = Create(Random);
       return base.Apply();

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammar.cs

@@ -21 +21 @@
 
 
+using System;
+using HeuristicLab.Core;
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
-  public interface ISymbolicExpressionGrammar : ISymbolicExpressionGrammarBase {
+  public interface ISymbolicExpressionGrammar : ISymbolicExpressionGrammarBase, IStatefulItem {
     ISymbol ProgramRootSymbol { get; }
     ISymbol StartSymbol { get; }
@@ -30 +32 @@
     int MinimumFunctionArguments { get; set; }
     int MaximumFunctionArguments { get; set; }
+
+    bool ReadOnly { get; set; }
+    event EventHandler ReadOnlyChanged;
   }
 }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammar.cs

@@ -20 +20 @@
 #endregion
 
-using System.Linq;
+using System;
 using HeuristicLab.Common;
+using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -28 +29 @@
   public abstract class SymbolicExpressionGrammar : SymbolicExpressionGrammarBase, ISymbolicExpressionGrammar {
     #region fields & properties
+    [Storable(DefaultValue = false)]
+    private bool readOnly;
+    public bool ReadOnly {
+      get { return readOnly; }
+      set {
+        if (readOnly != value) {
+          readOnly = value;
+          OnReadOnlyChanged();
+        }
+      }
+    }
+
     [Storable]
     private int minimumFunctionDefinitions;
@@ -102 +115 @@
     protected SymbolicExpressionGrammar(SymbolicExpressionGrammar original, Cloner cloner)
       : base(original, cloner) {
-      programRootSymbol = (ProgramRootSymbol)cloner.Clone(original.programRootSymbol);
-      startSymbol = (StartSymbol)cloner.Clone(original.StartSymbol);
-      defunSymbol = (Defun)cloner.Clone(original.defunSymbol);
-      symbols = original.symbols
-        .ToDictionary(x => x.Key, y => (ISymbol)cloner.Clone(y.Value));
+      programRootSymbol = cloner.Clone(original.programRootSymbol);
+      startSymbol = cloner.Clone(original.StartSymbol);
+      defunSymbol = cloner.Clone(original.defunSymbol);
+
       maximumFunctionArguments = original.maximumFunctionArguments;
       minimumFunctionArguments = original.minimumFunctionArguments;
@@ -140 +152 @@
       }
     }
+
+    public event EventHandler ReadOnlyChanged;
+    protected virtual void OnReadOnlyChanged() {
+      var handler = ReadOnlyChanged;
+      if (handler != null)
+        handler(this, EventArgs.Empty);
+    }
+
+    #region IStatefulItem
+    void IStatefulItem.InitializeState() { }
+    void IStatefulItem.ClearState() {
+      ReadOnly = false;
+    }
+    #endregion
   }
 }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs

@@ -81 +81 @@
       cachedMinExpressionDepth = new Dictionary<string, int>();
     }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      foreach (ISymbol symbol in symbols.Values)
+        RegisterSymbolEvents(symbol);
+    }
+
     protected SymbolicExpressionGrammarBase(SymbolicExpressionGrammarBase original, Cloner cloner)
       : base(original, cloner) {
@@ -87 +93 @@
       cachedMinExpressionDepth = new Dictionary<string, int>();
 
+
+      symbols = original.symbols.ToDictionary(x => x.Key, y => (ISymbol)cloner.Clone(y.Value));
       symbolSubtreeCount = new Dictionary<string, Tuple<int, int>>(original.symbolSubtreeCount);
-      symbols = new Dictionary<string, ISymbol>(original.symbols);
 
       allowedChildSymbols = new Dictionary<string, List<string>>();
@@ -97 +104 @@
       foreach (var element in original.allowedChildSymbolsPerIndex)
         allowedChildSymbolsPerIndex.Add(element.Key, new List<string>(element.Value));
+
+      foreach (ISymbol symbol in symbols.Values)
+        RegisterSymbolEvents(symbol);
     }
 
@@ -114 +124 @@
     protected void AddSymbol(ISymbol symbol) {
       if (ContainsSymbol(symbol)) throw new ArgumentException("Symbol " + symbol + " is already defined.");
+      RegisterSymbolEvents(symbol);
       symbols.Add(symbol.Name, symbol);
       symbolSubtreeCount.Add(symbol.Name, Tuple.Create(0, 0));
+      ClearCaches();
+    }
+
+    private void RegisterSymbolEvents(ISymbol symbol) {
+      symbol.NameChanging += new EventHandler<CancelEventArgs<string>>(Symbol_NameChanging);
+      symbol.NameChanged += new EventHandler(Symbol_NameChanged);
+    }
+    private void DeregisterSymbolEvents(ISymbol symbol) {
+      symbol.NameChanging -= new EventHandler<CancelEventArgs<string>>(Symbol_NameChanging);
+      symbol.NameChanged -= new EventHandler(Symbol_NameChanged);
+    }
+
+    private void Symbol_NameChanging(object sender, CancelEventArgs<string> e) {
+      if (symbols.ContainsKey(e.Value)) e.Cancel = true;
+    }
+    private void Symbol_NameChanged(object sender, EventArgs e) {
+      ISymbol symbol = (ISymbol)sender;
+      string oldName = symbols.Where(x => x.Value == symbol).First().Key;
+      string newName = symbol.Name;
+
+      symbols.Remove(oldName);
+      symbols.Add(newName, symbol);
+
+      var subtreeCount = symbolSubtreeCount[oldName];
+      symbolSubtreeCount.Remove(oldName);
+      symbolSubtreeCount.Add(newName, subtreeCount);
+
+      List<string> allowedChilds;
+      if (allowedChildSymbols.TryGetValue(oldName, out allowedChilds)) {
+        allowedChildSymbols.Remove(oldName);
+        allowedChildSymbols.Add(newName, allowedChilds);
+      }
+
+      for (int i = 0; i < GetMaximumSubtreeCount(symbol); i++) {
+        if (allowedChildSymbolsPerIndex.TryGetValue(Tuple.Create(oldName, i), out allowedChilds)) {
+          allowedChildSymbolsPerIndex.Remove(Tuple.Create(oldName, i));
+          allowedChildSymbolsPerIndex.Add(Tuple.Create(newName, i), allowedChilds);
+        }
+      }
+
+      foreach (var parent in Symbols) {
+        if (allowedChildSymbols.TryGetValue(parent.Name, out allowedChilds))
+          if (allowedChilds.Remove(oldName))
+            allowedChilds.Add(newName);
+
+        for (int i = 0; i < GetMaximumSubtreeCount(parent); i++) {
+          if (allowedChildSymbolsPerIndex.TryGetValue(Tuple.Create(parent.Name, i), out allowedChilds))
+            if (allowedChilds.Remove(oldName)) allowedChilds.Add(newName);
+        }
+      }
+
       ClearCaches();
     }
@@ -126 +188 @@
       symbolSubtreeCount.Remove(symbol.Name);
 
-
       foreach (var parent in Symbols) {
         List<string> allowedChilds;
@@ -137 +198 @@
         }
       }
+      DeregisterSymbolEvents(symbol);
       ClearCaches();
     }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeGrammar.cs

@@ -36 +36 @@
     }
     public override IDeepCloneable Clone(Cloner cloner) {
+      foreach (ISymbol symbol in base.Symbols)
+        cloner.RegisterClonedObject(symbol, symbol);
       return new SymbolicExpressionTreeGrammar(this, cloner);
     }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeTerminalNode.cs

@@ -45 +45 @@
     protected SymbolicExpressionTreeTerminalNode() : base() { }
 
-    protected SymbolicExpressionTreeTerminalNode(Symbol symbol)
+    protected SymbolicExpressionTreeTerminalNode(ISymbol symbol)
       : base() {
       // symbols are reused

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeTopLevelNode.cs

@@ -42 +42 @@
     }
     public SymbolicExpressionTreeTopLevelNode() : base() { }
-    public SymbolicExpressionTreeTopLevelNode(Symbol symbol) : base(symbol) { }
+    public SymbolicExpressionTreeTopLevelNode(ISymbol symbol) : base(symbol) { }
 
 

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/Argument.cs

@@ -38 +38 @@
     }
 
-    public override bool CanChangeDescription {
-      get { return false; }
-    }
-
     [StorableConstructor]
     private Argument(bool deserializing) : base(deserializing) { }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/InvokeFunction.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -38 +37 @@
     public string FunctionName {
       get { return functionName; }
-      set {
-        if (value == null) throw new ArgumentNullException();
-        functionName = value;
-      }
     }
 
@@ -53 +48 @@
     public InvokeFunction(string functionName)
       : base("Invoke: " + functionName, InvokeFunction.InvokeFunctionDescription) {
-      this.FunctionName = functionName;
+      this.functionName = functionName;
     }
 

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/Symbol.cs

@@ -43 +43 @@
     }
     public override bool CanChangeName {
-      get { return false; }
+      get { return !(this is IReadOnlySymbol); }
     }
     public override bool CanChangeDescription {
@@ -56 +56 @@
       initialFrequency = original.initialFrequency;
     }
-    protected Symbol()
-      : base() {
-      initialFrequency = 1.0;
-    }
 
     protected Symbol(string name, string description)
@@ -65 +61 @@
       initialFrequency = 1.0;
     }
-
 
     public virtual ISymbolicExpressionTreeNode CreateTreeNode() {