Changeset 11310 for branches/DataAnalysis.ComplexityAnalyzer/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisModelComplexityAnalyzer.cs

Timestamp:

08/27/14 10:29:38 (10 years ago)

Author:

mkommend

Message:

#2175: Merged trunk changes into complexity branch.

Location:

branches/DataAnalysis.ComplexityAnalyzer/HeuristicLab.Problems.DataAnalysis.Symbolic

Files:

• . (modified) (1 prop)
• 3.4/Analyzers/SymbolicDataAnalysisModelComplexityAnalyzer.cs (modified) (2 diffs)

branches/DataAnalysis.ComplexityAnalyzer/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisModelComplexityAnalyzer.cs

@@ -23 +23 @@
 
 using System;
-using System.Linq;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
@@ -29 +28 @@
   public class SymbolicDataAnalysisModelComplexityAnalyzer {
     public static double CalculateComplexity(ISymbolicExpressionTreeNode node) {
-      if (node is ConstantTreeNode) return 0;
-      if (node is VariableTreeNode) return 1;
+      switch (OpCodes.MapSymbolToOpCode(node)) {
+        case OpCodes.Constant: {
+            return 1;
+          }
+        case OpCodes.Variable: {
+            return 2;
+          }
+        case OpCodes.Add: {
+            double complexity = 0;
+            for (int i = 0; i < node.SubtreeCount; i++) {
+              complexity += CalculateComplexity(node.GetSubtree(i));
+            }
+            return complexity;
+          }
+        case OpCodes.Sub: {
+            double complexity = 0;
+            for (int i = 0; i < node.SubtreeCount; i++) {
+              complexity += CalculateComplexity(node.GetSubtree(i));
+            }
+            return complexity;
+          }
+        case OpCodes.Mul: {
+            double complexity = 1;
+            for (int i = 0; i < node.SubtreeCount; i++) {
+              complexity *= CalculateComplexity(node.GetSubtree(i));
+            }
+            return complexity == 1 ? node.SubtreeCount : complexity;
+          }
+        case OpCodes.Div: {
+            double complexity = 1;
+            for (int i = 0; i < node.SubtreeCount; i++) {
+              complexity *= CalculateComplexity(node.GetSubtree(i)) * 2;
+            }
+            return complexity;
+          }
+        case OpCodes.Sin: {
+            double complexity = CalculateComplexity(node.GetSubtree(0));
+            return complexity * 10;
+          }
+        case OpCodes.Cos: {
+            double complexity = CalculateComplexity(node.GetSubtree(0));
+            return complexity * 10;
+          }
+        case OpCodes.Tan: {
+            double complexity = CalculateComplexity(node.GetSubtree(0));
+            return complexity * 10;
+          }
+        case OpCodes.Exp: {
+            double complexity = CalculateComplexity(node.GetSubtree(0));
+            return complexity * 10;
+          }
+        case OpCodes.Log: {
+            double complexity = CalculateComplexity(node.GetSubtree(0));
+            return complexity * 10;
+          }
+        case OpCodes.Square: {
+            double complexity = CalculateComplexity(node.GetSubtree(0));
+            return 2 * complexity;
+          }
+        case OpCodes.SquareRoot: {
+            double complexity = CalculateComplexity(node.GetSubtree(0));
+            return 10 * complexity;
+          }
+        case OpCodes.Power: {
+            double complexity = CalculateComplexity(node.GetSubtree(0));
+            var exponentNode = node.GetSubtree(1) as ConstantTreeNode;
+            if (exponentNode != null) {
+              double exponent = exponentNode.Value;
+              if (exponent < 0) exponent = Math.Abs(exponent);
+              if (exponent < 1) exponent = 1 / exponent;
+              return Math.Pow(complexity, Math.Round(exponent));
+            }
 
-      var subtreeComplexities = node.Subtrees.Select(CalculateComplexity);
+            double exponentComplexity = CalculateComplexity(node.GetSubtree(1));
+            return Math.Pow(complexity, 2 * exponentComplexity);
+          }
+        case OpCodes.Root: {
+            double complexity = CalculateComplexity(node.GetSubtree(0));
+            var rootNode = node.GetSubtree(1) as ConstantTreeNode;
+            if (rootNode != null) {
+              double root = rootNode.Value;
+              if (root < 0) root = Math.Abs(root);
+              if (root < 1) root = 1 / root;
+              return Math.Pow(complexity, Math.Round(root));
+            }
 
-      double result = 0.0;
-      switch (OpCodes.MapSymbolToOpCode(node)) {
-        case OpCodes.Add:
-        case OpCodes.Sub:
-          foreach (var comp in subtreeComplexities) {
-            result += comp;
+            double rootComplexity = CalculateComplexity(node.GetSubtree(1));
+            return Math.Pow(complexity, 2 * rootComplexity);
           }
-          break;
-        case OpCodes.Mul:
-          result = 1;
-          foreach (var comp in subtreeComplexities) {
-            result *= comp + 1;
-          }
-          break;
-        //return subtreeComplexities.Aggregate((a, b) => a == 0 ? b : b == 0 ? a : (a + 1) * (b + 1));
-        case OpCodes.Div:
-          result = 1;
-          foreach (var comp in subtreeComplexities) {
-            result *= comp + 1;
-          }
-          result *= 2;
-          break;
-        //return subtreeComplexities.Aggregate((a, b) => a == 0 ? b * 2 : b == 0 ? a : (a + 1) * (b + 1) * 2);
+
         default:
           throw new NotSupportedException();
       }
-      return result;
     }
   }