Changeset 14238 for branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

Timestamp:

08/05/16 17:34:16 (8 years ago)

Author:

gkronber

Message:

#2650:

• added weight for FactorVariable (necessary for LR)
• introduced VariableBase and VariableTreeNodeBase and IVariableSymbol
• support for factors in LR
• extended variable impacts in solution view
• fixed ERC view for regression
• support for FactorVariable in simplifier
• improved support for FactorVariable in constants optimizer
• multiple related changes and small fixes

File:

• branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs (modified) (9 diffs)

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

@@ -182 +182 @@
       return node.Symbol is Variable;
     }
-
+    private bool IsVariableBase(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is VariableBase;
+    }
     private bool IsConstant(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Constant;
@@ -203 +205 @@
     /// <returns></returns>
     public ISymbolicExpressionTreeNode GetSimplifiedTree(ISymbolicExpressionTreeNode original) {
-      if (IsConstant(original) || IsVariable(original)) {
+      if (IsConstant(original) || IsVariableBase(original)) {
         return (ISymbolicExpressionTreeNode)original.Clone();
       } else if (IsAddition(original)) {
@@ -718 +720 @@
       } if (IsConstant(a) && !((ConstantTreeNode)a).Value.IsAlmost(1.0)) {
         return MakeFraction(MakeConstant(1.0), MakeProduct(b, Invert(a)));
-      } else if (IsVariable(a) && IsConstant(b)) {
+      } else if (IsVariableBase(a) && IsConstant(b)) {
         // merge constant values into variable weights
         var constB = ((ConstantTreeNode)b).Value;
-        ((VariableTreeNode)a).Weight /= constB;
+        ((VariableTreeNodeBase)a).Weight /= constB;
         return a;
-      } else if (IsVariable(a) && IsVariable(b) && AreSameVariable(a, b)) {
+      } else if (IsVariableBase(a) && IsVariableBase(b) && AreSameVariable(a, b)) {
         // cancel variables
         var aVar = a as VariableTreeNode;
@@ -835 +837 @@
       var groupedVarNodes = from node in subtrees.OfType<VariableTreeNodeBase>()
                             let lag = (node is LaggedVariableTreeNode) ? ((LaggedVariableTreeNode)node).Lag : 0
-                            group node by node.VariableName + lag into g
+                            let cat = (node is FactorVariableTreeNode) ? ((FactorVariableTreeNode)node).VariableValue : string.Empty
+                            group node by node.VariableName + cat + lag into g
                             select g;
       var unchangedSubtrees = subtrees.Where(t => !(t is VariableTreeNodeBase));
@@ -861 +864 @@
         // $ * 1.0 => $
         return a;
-      } else if (IsConstant(b) && IsVariable(a)) {
+      } else if (IsConstant(b) && IsVariableBase(a)) {
         // multiply constants into variables weights
-        ((VariableTreeNode)a).Weight *= ((ConstantTreeNode)b).Value;
+        ((VariableTreeNodeBase)a).Weight *= ((ConstantTreeNode)b).Value;
         return a;
       } else if (IsConstant(b) && IsAddition(a)) {
@@ -944 +947 @@
         return aVar.VariableName == bVar.VariableName;
       }
+      var aFactor = a as FactorVariableTreeNode;
+      var bFactor = b as FactorVariableTreeNode;
+      if (aFactor != null && bFactor != null) {
+        return aFactor.VariableName == bFactor.VariableName &&
+          aFactor.VariableValue == bFactor.VariableValue;
+      }
+
       return false;
     }
@@ -951 +961 @@
       var subtrees = new List<ISymbolicExpressionTreeNode>(prod.Subtrees);
       while (prod.Subtrees.Any()) prod.RemoveSubtree(0);
-      var groupedVarNodes = from node in subtrees.OfType<VariableTreeNode>()
+      var groupedVarNodes = from node in subtrees.OfType<VariableTreeNodeBase>()
                             let lag = (node is LaggedVariableTreeNode) ? ((LaggedVariableTreeNode)node).Lag : 0
                             group node by node.VariableName + lag into g
                             orderby g.Count()
                             select g;
-      var constantProduct = (from node in subtrees.OfType<VariableTreeNode>()
+      var constantProduct = (from node in subtrees.OfType<VariableTreeNodeBase>()
                              select node.Weight)
                             .Concat(from node in subtrees.OfType<ConstantTreeNode>()
@@ -964 +974 @@
 
       var unchangedSubtrees = from tree in subtrees
-                              where !(tree is VariableTreeNode)
+                              where !(tree is VariableTreeNodeBase)
                               where !(tree is ConstantTreeNode)
                               select tree;
@@ -1000 +1010 @@
       if (IsConstant(x)) {
         ((ConstantTreeNode)x).Value *= -1;
-      } else if (IsVariable(x)) {
-        var variableTree = (VariableTreeNode)x;
+      } else if (IsVariableBase(x)) {
+        var variableTree = (VariableTreeNodeBase)x;
         variableTree.Weight *= -1.0;
       } else if (IsAddition(x)) {