Changeset 5729 for branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4

Timestamp:

03/17/11 12:25:30 (13 years ago)

Author:

gkronber

Message:

#1418 moved liner scaling method into symbolic regression model and fixed bug in interactive solution simplifier

File:

• branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs (modified) (8 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs

@@ -33 +33 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
   public abstract partial class InteractiveSymbolicDataAnalysisSolutionSimplifierView : AsynchronousContentView {
-    private Dictionary<ISymbolicExpressionTreeNode, ConstantTreeNode> replacementNodes;
+    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> replacementNodes;
     private Dictionary<ISymbolicExpressionTreeNode, double> nodeImpacts;
 
     public InteractiveSymbolicDataAnalysisSolutionSimplifierView() {
       InitializeComponent();
-      this.replacementNodes = new Dictionary<ISymbolicExpressionTreeNode, ConstantTreeNode>();
+      this.replacementNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
       this.nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
       this.Caption = "Interactive Solution Simplifier";
@@ -81 +81 @@
 
     private void CalculateReplacementNodesAndNodeImpacts() {
-      replacementNodes.Clear();
       if (Content != null && Content.Model != null && Content.ProblemData != null) {
         var tree = Content.Model.SymbolicExpressionTree;
         var replacementValues = CalculateReplacementValues(tree);
         foreach (var pair in replacementValues) {
-          replacementNodes.Add(pair.Key, MakeConstantTreeNode(pair.Value));
+          if (!(pair.Key is ConstantTreeNode)) {
+            replacementNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
+          }
         }
         nodeImpacts = CalculateImpactValues(Content.Model.SymbolicExpressionTree);
@@ -96 +97 @@
             var child = parent.GetSubTree(subTreeIndex);
             if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(1.0)) {
-              ReplaceNodeWithConstant(parent, subTreeIndex);
+              SwitchNodeWithReplacementNode(parent, subTreeIndex);
             }
           }
@@ -126 +127 @@
           ISymbolicExpressionTreeNode subTree = treeNode.GetSubTree(i);
           if (subTree == visualTreeNode.SymbolicExpressionTreeNode) {
-            ReplaceNodeWithConstant(treeNode, i);
+            SwitchNodeWithReplacementNode(treeNode, i);
           }
         }
@@ -138 +139 @@
     }
 
-    private void ReplaceNodeWithConstant(ISymbolicExpressionTreeNode parent, int subTreeIndex) {
+    private void SwitchNodeWithReplacementNode(ISymbolicExpressionTreeNode parent, int subTreeIndex) {
       ISymbolicExpressionTreeNode subTree = parent.GetSubTree(subTreeIndex);
       parent.RemoveSubTree(subTreeIndex);
-      if (replacementNodes.ContainsKey(subTree))
-        parent.InsertSubTree(subTreeIndex, replacementNodes[subTree]);
-      else if (subTree is ConstantTreeNode && replacementNodes.ContainsValue((ConstantTreeNode)subTree))
-        parent.InsertSubTree(subTreeIndex, replacementNodes.Where(v => v.Value == subTree).Single().Key);
-      else if (!(subTree is ConstantTreeNode))
+      if (replacementNodes.ContainsKey(subTree)) {
+        var replacementNode = replacementNodes[subTree];
+        parent.InsertSubTree(subTreeIndex, replacementNode);
+        // exchange key and value 
+        replacementNodes.Remove(subTree);
+        replacementNodes.Add(replacementNode, subTree);
+      } else {
         throw new InvalidOperationException("Could not find replacement value.");
+      }
     }
 
@@ -155 +159 @@
       foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
         if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
-          double impact = this.nodeImpacts[treeNode];
-          double replacementValue = this.replacementNodes[treeNode].Value;
+          double impact = nodeImpacts[treeNode];
           VisualSymbolicExpressionTreeNode visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
 
@@ -163 +166 @@
           // impact > 0 if new solution is worse
           if (impact < 0.0) {
+            // min is guaranteed to be < 0
             visualTree.FillColor = Color.FromArgb((int)(impact / min * 255), Color.Red);
+          } else if (impact.IsAlmost(0.0)) {
+            visualTree.FillColor = Color.White;
           } else {
+            // max is guaranteed to be > 0
             visualTree.FillColor = Color.FromArgb((int)(impact / max * 255), Color.Green);
           }
           visualTree.ToolTip += Environment.NewLine + "Node impact: " + impact;
-          visualTree.ToolTip += Environment.NewLine + "Replacement value: " + replacementValue;
+          var constantReplacementNode = replacementNodes[treeNode] as ConstantTreeNode;
+          if (constantReplacementNode != null) {
+            visualTree.ToolTip += Environment.NewLine + "Replacement value: " + constantReplacementNode.Value;
+          }
         }
       }
@@ -177 +187 @@
     private void PaintCollapsedNodes() {
       foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
-        if (treeNode is ConstantTreeNode && replacementNodes.ContainsValue((ConstantTreeNode)treeNode))
+        if (treeNode is ConstantTreeNode && replacementNodes.ContainsKey(treeNode))
           this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = Color.DarkOrange;
         else {