Changeset 17597

Timestamp:

06/10/20 17:17:43 (4 years ago)

Author:

pfleck

Message:

#3040: Added simplification rules for length-aggregation.

File:

• branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/VectorTreeSimplifier.cs (modified) (17 diffs)

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/VectorTreeSimplifier.cs

@@ -267 +267 @@
     private static bool IsMean(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Mean;
+    }
+
+    private static bool IsLength(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is Length;
     }
     #endregion
@@ -345 +349 @@
       } else if (IsMean(original)) {
         return SimplifyMeanAggregation(original);
+      } else if (IsLength(original)) {
+        return SimplifyLengthAggregation(original);
       } else {
         return SimplifyAny(original);
@@ -546 +552 @@
     }
 
+    private ISymbolicExpressionTreeNode SimplifyLengthAggregation(ISymbolicExpressionTreeNode original) {
+      return MakeLengthAggregation(GetSimplifiedTree(original.GetSubtree(0)));
+    }
     #endregion
 
@@ -1367 +1376 @@
     }
 
-    ISymbolicExpressionTreeNode MakeSumAggregation(ISymbolicExpressionTreeNode node) {
+    private ISymbolicExpressionTreeNode MakeSumAggregation(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) { // assumes scalar constant
         return node;
       } else if (IsAddition(node) || IsSubtraction(node)) {
         var terms = node.Subtrees;
-        if (IsSubtraction(node)) {
-          if (terms.Count() == 1) {
-            terms = terms.Select(Negate);
-          } else {
-            var first = terms.First().ToEnumerable();
-            var remaining = terms.Skip(1).Select(Negate);
-            terms = first.Concat(remaining).ToList();
-          }
-        }
+        if (IsSubtraction(node)) terms = InvertNodes(terms, Negate);
 
         var scalarTerms = terms.Where(IsScalarNode).ToList();
@@ -1389 +1390 @@
           var vectorNode = remainingTerms.Aggregate(MakeSum);
 
-          var lengthNode = lengthSymbol.CreateTreeNode();
-          lengthNode.AddSubtree((ISymbolicExpressionTreeNode)vectorNode.Clone());
-          var scalarMulNode = mulSymbol.CreateTreeNode();
-          scalarMulNode.AddSubtree(scalarNode);
-          scalarMulNode.AddSubtree(lengthNode);
-
-          var sumNode = sumSymbol.CreateTreeNode();
-          sumNode.AddSubtree(vectorNode);
+          var lengthNode = MakeLengthAggregation((ISymbolicExpressionTreeNode)vectorNode.Clone());
+          var scalarMulNode = MakeProduct(scalarNode, lengthNode);
+
+          var sumNode = MakeSumAggregation(vectorNode);
 
           return MakeSum(scalarMulNode, sumNode);
@@ -1411 +1408 @@
       } else if (IsMultiplication(node) || IsDivision(node)) {
         var factors = node.Subtrees;
-        if (IsDivision(node)) {
-          if (factors.Count() == 1) {
-            factors = factors.Select(Invert);
-          } else {
-            var first = factors.First().ToEnumerable();
-            var remaining = factors.Skip(1).Select(Invert);
-            factors = first.Concat(remaining).ToList();
-          }
-        }
+        if (IsDivision(node)) factors = InvertNodes(factors, Invert);
 
         var scalarFactors = factors.Where(IsScalarNode).ToList();
@@ -1428 +1417 @@
           var vectorNode = remainingFactors.Aggregate(MakeProduct);
 
-          var sumNode = sumSymbol.CreateTreeNode();
-          sumNode.AddSubtree(vectorNode);
+          var sumNode = MakeSumAggregation(vectorNode);
 
           return MakeProduct(scalarNode, sumNode);
@@ -1442 +1430 @@
         } else
           throw new InvalidOperationException("Multiplication does not contain any terms to simplify.");
+      } else if (IsVariableBase(node)) { // weight is like multiplication
+        var variableNode = (VariableTreeNodeBase)node;
+        var weight = variableNode.Weight;
+        variableNode.Weight = 1.0;
+        var sumNode = sumSymbol.CreateTreeNode();
+        sumNode.AddSubtree(node);
+        return MakeProduct(MakeConstant(weight), sumNode);
       } else {
         var sumNode = sumSymbol.CreateTreeNode();
@@ -1449 +1444 @@
     }
 
-    ISymbolicExpressionTreeNode MakeMeanAggregation(ISymbolicExpressionTreeNode node) {
+    private ISymbolicExpressionTreeNode MakeMeanAggregation(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) { // assumes scalar constant
         return node;
       } else if (IsAddition(node) || IsSubtraction(node)) {
         var terms = node.Subtrees;
-        if (IsSubtraction(node)) {
-          if (terms.Count() == 1) {
-            terms = terms.Select(Negate);
-          } else {
-            var first = terms.First().ToEnumerable();
-            var remaining = terms.Skip(1).Select(Negate);
-            terms = first.Concat(remaining).ToList();
-          }
-        }
+        if (IsSubtraction(node)) terms = InvertNodes(terms, Negate);
 
         var scalarTerms = terms.Where(IsScalarNode).ToList();
@@ -1471 +1458 @@
           var vectorNode = remainingTerms.Aggregate(MakeSum);
 
-          var meanNode = meanSymbol.CreateTreeNode();
-          meanNode.AddSubtree(vectorNode);
+          var meanNode = MakeMeanAggregation(vectorNode);
 
           return MakeSum(scalarNode, meanNode);
@@ -1487 +1473 @@
       } else if (IsMultiplication(node) || IsDivision(node)) {
         var factors = node.Subtrees;
-        if (IsDivision(node)) {
-          if (factors.Count() == 1) {
-            factors = factors.Select(Invert);
-          } else {
-            var first = factors.First().ToEnumerable();
-            var remaining = factors.Skip(1).Select(Invert);
-            factors = first.Concat(remaining).ToList();
-          }
-        }
+        if (IsDivision(node)) factors = InvertNodes(factors, Invert);
 
         var scalarFactors = factors.Where(IsScalarNode).ToList();
@@ -1504 +1482 @@
           var vectorNode = remainingFactors.Aggregate(MakeProduct);
 
-          var meanNode = meanSymbol.CreateTreeNode();
-          meanNode.AddSubtree(vectorNode);
+          var meanNode = MakeMeanAggregation(vectorNode);
 
           return MakeProduct(scalarNode, meanNode);
@@ -1518 +1495 @@
         } else
           throw new InvalidOperationException("Multiplication does not contain any terms to simplify.");
+      } else if (IsVariableBase(node)) { // weight is like multiplication
+        var variableNode = (VariableTreeNodeBase)node;
+        var weight = variableNode.Weight;
+        variableNode.Weight = 1.0;
+        var meanNode = meanSymbol.CreateTreeNode();
+        meanNode.AddSubtree(node);
+        return MakeProduct(MakeConstant(weight), meanNode);
       } else {
         var meanNode = meanSymbol.CreateTreeNode();
         meanNode.AddSubtree(node);
         return meanNode;
+      }
+    }
+
+    private ISymbolicExpressionTreeNode MakeLengthAggregation(ISymbolicExpressionTreeNode node) {
+      if (IsConstant(node)) { // assumes scalar constant
+        return MakeConstant(1.0);
+      } else if (IsAddition(node) || IsSubtraction(node)) {
+        var terms = node.Subtrees;
+        if (IsSubtraction(node)) terms = InvertNodes(terms, Negate);
+
+        var scalarTerms = terms.Where(IsScalarNode).ToList();
+        var remainingTerms = terms.Except(scalarTerms).ToList();
+
+        if (remainingTerms.Any()) {
+          var vectorNode = remainingTerms.Aggregate(MakeSum);
+
+          var lengthNode = lengthSymbol.CreateTreeNode();
+          lengthNode.AddSubtree(vectorNode);
+
+          return lengthNode;
+        } else if (scalarTerms.Any()) {
+          return MakeConstant(1.0);
+        } else
+          throw new InvalidOperationException("Addition does not contain any terms to simplify.");
+      } else if (IsMultiplication(node) || IsDivision(node)) {
+        var factors = node.Subtrees;
+        if (IsDivision(node)) factors = InvertNodes(factors, Invert);
+
+        var scalarFactors = factors.Where(IsScalarNode).ToList();
+        var remainingFactors = factors.Except(scalarFactors).ToList();
+
+        if (remainingFactors.Any()) {
+          var vectorNode = remainingFactors.Aggregate(MakeProduct);
+
+          var lengthNode = lengthSymbol.CreateTreeNode();
+          lengthNode.AddSubtree(vectorNode);
+
+          return lengthNode;
+        } else if (scalarFactors.Any()) {
+          return MakeConstant(1.0);
+        } else
+          throw new InvalidOperationException("Multiplication does not contain any terms to simplify.");
+      } else if (IsVariableBase(node)) { // weight is like multiplication
+        var variableNode = (VariableTreeNodeBase)node;
+        variableNode.Weight = 1.0;
+        var lengthNode = lengthSymbol.CreateTreeNode();
+        lengthNode.AddSubtree(node);
+        return lengthNode;
+      } else {
+        var lengthNode = lengthSymbol.CreateTreeNode();
+        lengthNode.AddSubtree(node);
+        return lengthNode;
       }
     }
@@ -1678 +1714 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeConstant(double value) {
+    private static ISymbolicExpressionTreeNode MakeConstant(double value) {
       ConstantTreeNode constantTreeNode = (ConstantTreeNode)(constSymbol.CreateTreeNode());
       constantTreeNode.Value = value;
@@ -1684 +1720 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeFactor(FactorVariable sy, string variableName, IEnumerable<double> weights) {
+    private static ISymbolicExpressionTreeNode MakeFactor(FactorVariable sy, string variableName, IEnumerable<double> weights) {
       var tree = (FactorVariableTreeNode)sy.CreateTreeNode();
       tree.VariableName = variableName;
@@ -1690 +1726 @@
       return tree;
     }
-    private ISymbolicExpressionTreeNode MakeBinFactor(BinaryFactorVariable sy, string variableName, string variableValue, double weight) {
+    private static ISymbolicExpressionTreeNode MakeBinFactor(BinaryFactorVariable sy, string variableName, string variableValue, double weight) {
       var tree = (BinaryFactorVariableTreeNode)sy.CreateTreeNode();
       tree.VariableName = variableName;
@@ -1697 +1733 @@
       return tree;
     }
-
+    private static IEnumerable<ISymbolicExpressionTreeNode> InvertNodes(IEnumerable<ISymbolicExpressionTreeNode> nodes, Func<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> invertFunc) {
+      if (nodes.Count() == 1)
+        return nodes.Select(invertFunc);
+      var first = nodes.First().ToEnumerable();
+      var remaining = nodes.Skip(1).Select(invertFunc);
+      return first.Concat(remaining);
+    }
 
     #endregion