Changeset 9126 for branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs

Timestamp:

01/08/13 15:36:13 (12 years ago)

Author:

mkommend

Message:

#1837: Updated sliding window GP branch with trunk changes.

Location:

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views

Files:

• . (modified) (1 prop)
• 3.4 (modified) (1 prop)
• 3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs (modified) (7 diffs)

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4

@@ -2 +2 @@
 obj
 *.user
-HeuristicLabProblemsDataAnalysisSymbolicViewsPlugin.cs
 *.vs10x
 Plugin.cs

@@ -2 +2 @@
 obj
 *.user
-HeuristicLabProblemsDataAnalysisSymbolicViewsPlugin.cs
 *.vs10x
 Plugin.cs

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs

@@ -32 +32 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
   public abstract partial class InteractiveSymbolicDataAnalysisSolutionSimplifierView : AsynchronousContentView {
-    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> replacementNodes;
+    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> foldedNodes;
+    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> changedNodes;
     private Dictionary<ISymbolicExpressionTreeNode, double> nodeImpacts;
-    private bool updateInProgress = false;
+    private enum TreeState { Valid, Invalid }
+    private TreeState treeState;
 
     public InteractiveSymbolicDataAnalysisSolutionSimplifierView() {
       InitializeComponent();
-      this.replacementNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
-      this.nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
+      foldedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
+      changedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
+      nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
       this.Caption = "Interactive Solution Simplifier";
+
+      // initialize the tree modifier that will be used to perform edit operations over the tree
+      treeChart.ModifyTree = Modify;
+    }
+
+    /// <summary>
+    /// Remove, Replace or Insert subtrees
+    /// </summary>
+    /// <param name="tree">The symbolic expression tree</param>
+    /// <param name="node">The insertion point (ie, the parent node who will receive a new child)</param>
+    /// <param name="oldChild">The subtree to be replaced</param>
+    /// <param name="newChild">The replacement subtree</param>
+    /// <param name="removeSubtree">Flag used to indicate if whole subtrees should be removed (default behavior), or just the subtree root</param>
+    private void Modify(ISymbolicExpressionTree tree, ISymbolicExpressionTreeNode node, ISymbolicExpressionTreeNode oldChild, ISymbolicExpressionTreeNode newChild, bool removeSubtree = true) {
+      if (oldChild == null && newChild == null) throw new ArgumentException();
+      if (oldChild == null) { // insertion operation
+        node.AddSubtree(newChild);
+        newChild.Parent = node;
+      } else if (newChild == null) { // removal operation
+        node.RemoveSubtree(node.IndexOfSubtree(oldChild));
+        changedNodes.Remove(oldChild);
+        foldedNodes.Remove(oldChild);
+        if (removeSubtree) {
+          foreach (var subtree in oldChild.IterateNodesPrefix()) {
+            changedNodes.Remove(subtree);
+            foldedNodes.Remove(subtree);
+          }
+        } else {
+          for (int i = oldChild.SubtreeCount - 1; i >= 0; --i) {
+            var subtree = oldChild.GetSubtree(i);
+            oldChild.RemoveSubtree(i);
+            node.AddSubtree(subtree);
+          }
+        }
+      } else { // replacement operation
+        var replacementIndex = node.IndexOfSubtree(oldChild);
+        node.RemoveSubtree(replacementIndex);
+        node.InsertSubtree(replacementIndex, newChild);
+        newChild.Parent = node;
+        if (changedNodes.ContainsKey(oldChild)) {
+          changedNodes.Add(newChild, changedNodes[oldChild]); // so that on double click the original node is restored
+          changedNodes.Remove(oldChild);
+        } else {
+          changedNodes.Add(newChild, oldChild);
+        }
+      }
+      if (IsValid(tree)) {
+        treeState = TreeState.Valid;
+        UpdateModel(Content.Model.SymbolicExpressionTree);
+      } else {
+        treeState = TreeState.Invalid;
+      }
+    }
+
+    private bool IsValid(ISymbolicExpressionTree tree) {
+      treeChart.Tree = tree;
+      treeChart.Repaint();
+      bool valid = !tree.IterateNodesPostfix().Any(node => node.SubtreeCount < node.Symbol.MinimumArity || node.SubtreeCount > node.Symbol.MaximumArity);
+      if (valid) {
+        btnOptimizeConstants.Enabled = true;
+        btnSimplify.Enabled = true;
+        treeStatusValue.Text = "Valid";
+        treeStatusValue.ForeColor = Color.Green;
+      } else {
+        btnOptimizeConstants.Enabled = false;
+        btnSimplify.Enabled = false;
+        treeStatusValue.Text = "Invalid";
+        treeStatusValue.ForeColor = Color.Red;
+      }
+      this.Refresh();
+      return valid;
     }
 
@@ -50 +124 @@
     protected override void RegisterContentEvents() {
       base.RegisterContentEvents();
-      Content.ModelChanged += new EventHandler(Content_ModelChanged);
-      Content.ProblemDataChanged += new EventHandler(Content_ProblemDataChanged);
+      Content.ModelChanged += Content_Changed;
+      Content.ProblemDataChanged += Content_Changed;
     }
     protected override void DeregisterContentEvents() {
       base.DeregisterContentEvents();
-      Content.ModelChanged -= new EventHandler(Content_ModelChanged);
-      Content.ProblemDataChanged -= new EventHandler(Content_ProblemDataChanged);
-    }
-
-    private void Content_ModelChanged(object sender, EventArgs e) {
-      OnModelChanged();
-    }
-    private void Content_ProblemDataChanged(object sender, EventArgs e) {
-      OnProblemDataChanged();
-    }
-
-    protected virtual void OnModelChanged() {
-      this.CalculateReplacementNodesAndNodeImpacts();
-    }
-
-    protected virtual void OnProblemDataChanged() {
-      this.CalculateReplacementNodesAndNodeImpacts();
+      Content.ModelChanged -= Content_Changed;
+      Content.ProblemDataChanged -= Content_Changed;
+    }
+
+    private void Content_Changed(object sender, EventArgs e) {
+      UpdateView();
     }
 
     protected override void OnContentChanged() {
       base.OnContentChanged();
-      this.CalculateReplacementNodesAndNodeImpacts();
-      this.viewHost.Content = this.Content;
-    }
-
-    private void CalculateReplacementNodesAndNodeImpacts() {
-      if (Content != null && Content.Model != null && Content.ProblemData != null) {
-        var tree = Content.Model.SymbolicExpressionTree;
-        var replacementValues = CalculateReplacementValues(tree);
-        foreach (var pair in replacementValues) {
-          if (!(pair.Key is ConstantTreeNode)) {
-            replacementNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
-          }
-        }
-        nodeImpacts = CalculateImpactValues(Content.Model.SymbolicExpressionTree);
-
-        if (!updateInProgress) {
-          // automatically fold all branches with impact = 1
-          List<ISymbolicExpressionTreeNode> nodeList = Content.Model.SymbolicExpressionTree.Root.GetSubtree(0).IterateNodesPrefix().ToList();
-          foreach (var parent in nodeList) {
-            for (int subTreeIndex = 0; subTreeIndex < parent.SubtreeCount; subTreeIndex++) {
-              var child = parent.GetSubtree(subTreeIndex);
-              if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(0.0)) {
-                SwitchNodeWithReplacementNode(parent, subTreeIndex);
-              }
-            }
-          }
-        }
-
-        // show only interesting part of solution 
-        if (tree.Root.SubtreeCount > 1)
-          this.treeChart.Tree = new SymbolicExpressionTree(tree.Root); // RPB + ADFs
-        else
-          this.treeChart.Tree = new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0)); // 1st child of RPB
-        this.PaintNodeImpacts();
-      }
+      foldedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
+      UpdateView();
+      viewHost.Content = this.Content;
+    }
+
+    private void UpdateView() {
+      if (Content == null || Content.Model == null || Content.ProblemData == null) return;
+      var tree = Content.Model.SymbolicExpressionTree;
+      treeChart.Tree = tree.Root.SubtreeCount > 1 ? new SymbolicExpressionTree(tree.Root) : new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0));
+
+      var replacementValues = CalculateReplacementValues(tree);
+      foreach (var pair in replacementValues.Where(pair => !(pair.Key is ConstantTreeNode))) {
+        foldedNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
+      }
+
+      nodeImpacts = CalculateImpactValues(tree);
+      PaintNodeImpacts();
     }
 
@@ -117 +162 @@
     protected abstract void UpdateModel(ISymbolicExpressionTree tree);
 
-    private ConstantTreeNode MakeConstantTreeNode(double value) {
-      Constant constant = new Constant();
-      constant.MinValue = value - 1;
-      constant.MaxValue = value + 1;
-      ConstantTreeNode constantTreeNode = (ConstantTreeNode)constant.CreateTreeNode();
+    private static ConstantTreeNode MakeConstantTreeNode(double value) {
+      var constant = new Constant { MinValue = value - 1, MaxValue = value + 1 };
+      var constantTreeNode = (ConstantTreeNode)constant.CreateTreeNode();
       constantTreeNode.Value = value;
       return constantTreeNode;
@@ -127 +170 @@
 
     private void treeChart_SymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
-      VisualSymbolicExpressionTreeNode visualTreeNode = (VisualSymbolicExpressionTreeNode)sender;
+      if (treeState == TreeState.Invalid) return;
+      var visualNode = (VisualSymbolicExpressionTreeNode)sender;
+      var symbExprTreeNode = (SymbolicExpressionTreeNode)visualNode.SymbolicExpressionTreeNode;
+      if (symbExprTreeNode == null) return;
       var tree = Content.Model.SymbolicExpressionTree;
-      foreach (SymbolicExpressionTreeNode treeNode in tree.IterateNodesPostfix()) {
-        for (int i = 0; i < treeNode.SubtreeCount; i++) {
-          ISymbolicExpressionTreeNode subTree = treeNode.GetSubtree(i);
-          // only allow to replace nodes for which a replacement value is known (replacement value for ADF nodes are not available)
-          if (subTree == visualTreeNode.SymbolicExpressionTreeNode && replacementNodes.ContainsKey(subTree)) {
-            SwitchNodeWithReplacementNode(treeNode, i);
-
-            // show only interesting part of solution 
-            if (tree.Root.SubtreeCount > 1)
-              this.treeChart.Tree = new SymbolicExpressionTree(tree.Root); // RPB + ADFs
-            else
-              this.treeChart.Tree = new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0)); // 1st child of RPB
-
-            updateInProgress = true;
-            UpdateModel(tree);
-            updateInProgress = false;
-            return; // break all loops
-          }
-        }
-      }
+      var parent = symbExprTreeNode.Parent;
+      int indexOfSubtree = parent.IndexOfSubtree(symbExprTreeNode);
+      if (changedNodes.ContainsKey(symbExprTreeNode)) {
+        // undo node change
+        parent.RemoveSubtree(indexOfSubtree);
+        var originalNode = changedNodes[symbExprTreeNode];
+        parent.InsertSubtree(indexOfSubtree, originalNode);
+        changedNodes.Remove(symbExprTreeNode);
+      } else if (foldedNodes.ContainsKey(symbExprTreeNode)) {
+        // undo node folding
+        SwitchNodeWithReplacementNode(parent, indexOfSubtree);
+      }
+      UpdateModel(tree);
     }
 
@@ -154 +193 @@
       ISymbolicExpressionTreeNode subTree = parent.GetSubtree(subTreeIndex);
       parent.RemoveSubtree(subTreeIndex);
-      if (replacementNodes.ContainsKey(subTree)) {
-        var replacementNode = replacementNodes[subTree];
+      if (foldedNodes.ContainsKey(subTree)) {
+        var replacementNode = foldedNodes[subTree];
         parent.InsertSubtree(subTreeIndex, replacementNode);
         // exchange key and value 
-        replacementNodes.Remove(subTree);
-        replacementNodes.Add(replacementNode, subTree);
+        foldedNodes.Remove(subTree);
+        foldedNodes.Add(replacementNode, subTree);
       }
     }
@@ -168 +207 @@
       double min = impacts.Min();
       foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
+        VisualSymbolicExpressionTreeNode visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
+
         if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
           double impact = nodeImpacts[treeNode];
-          VisualSymbolicExpressionTreeNode visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
 
           // impact = 0 if no change
@@ -185 +225 @@
           }
           visualTree.ToolTip += Environment.NewLine + "Node impact: " + impact;
-          var constantReplacementNode = replacementNodes[treeNode] as ConstantTreeNode;
+          var constantReplacementNode = foldedNodes[treeNode] as ConstantTreeNode;
           if (constantReplacementNode != null) {
             visualTree.ToolTip += Environment.NewLine + "Replacement value: " + constantReplacementNode.Value;
           }
         }
-      }
-      this.PaintCollapsedNodes();
-      this.treeChart.Repaint();
-    }
-
-    private void PaintCollapsedNodes() {
-      foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
-        if (treeNode is ConstantTreeNode && replacementNodes.ContainsKey(treeNode))
-          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = Color.DarkOrange;
-        else {
-          VisualSymbolicExpressionTreeNode visNode = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
-          if (visNode != null)
-            visNode.LineColor = Color.Black;
-        }
-      }
+        if (visualTree != null)
+          if (changedNodes.ContainsKey(treeNode)) {
+            visualTree.LineColor = Color.DodgerBlue;
+          } else if (treeNode is ConstantTreeNode && foldedNodes.ContainsKey(treeNode)) {
+            visualTree.LineColor = Color.DarkOrange;
+          }
+      }
+      treeChart.RepaintNodes();
     }
 
     private void btnSimplify_Click(object sender, EventArgs e) {
-      SymbolicDataAnalysisExpressionTreeSimplifier simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
+      var simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
       var simplifiedExpressionTree = simplifier.Simplify(Content.Model.SymbolicExpressionTree);
       UpdateModel(simplifiedExpressionTree);

@@ -2 +2 @@
 obj
 *.user
-HeuristicLabProblemsDataAnalysisSymbolicViewsPlugin.cs
 *.vs10x
 Plugin.cs