Changeset 11458 for branches/HeuristicLab.EvolutionTracking

Timestamp:

10/13/14 13:03:24 (10 years ago)

Author:

bburlacu

Message:

#1772: HeuristicLab.Problems.DataAnalysis.Symbolic:

• Merged trunk changes (SymbolicExpressionImporter)
• Added Passthrough symbol (does not perform an operation, just transfers the input), adjusted interpreter and opcodes accordingly
• Added diversity preserving crossover
• Replaced IDistanceCalculator interface with ISymbolicDataAnalysisExpressionSimilarityCalculator and adjusted similarity calculators
• Refactored tracing, moved functionality to the TraceCalculator (when this is complete the old code will be removed)

Location:

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• . (modified) (1 prop)
• Analyzers/BuildingBlockAnalyzers (added)
• Analyzers/BuildingBlockAnalyzers/SymbolicDataAnalysisPoly10Analyzer.cs (added)
• Crossovers (modified) (1 prop)
• Crossovers/SymbolicDataAnalysisExpressionDiversityPreservingCrossover.cs (added)
• Crossovers/SymbolicDataAnalysisExpressionSizefairCrossover.cs (deleted)
• Grammars/TypeCoherentExpressionGrammar.cs (modified) (5 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (5 diffs)
• Importer (copied) (copied from trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer)
• Interfaces/ISymbolicDataAnalysisExpressionSimilarityCalculator.cs (moved) (moved from branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IDistanceCalculator.cs) (1 diff)
• Interpreter/OpCodes.cs (modified) (3 diffs)
• Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs (modified) (2 diffs)
• Matching/SymbolicExpressionTreeMatching.cs (modified) (3 diffs, 1 prop)
• SimilarityCalculators/BottomUpSimilarityCalculator.cs (modified) (4 diffs)
• SimilarityCalculators/MaxCommonSubtreeSimilarityCalculator.cs (modified) (3 diffs)
• SimilarityCalculators/PhenotypicSimilarityCalculator.cs (modified) (3 diffs)
• Symbols/Passthrough.cs (added)
• Tracking/SymbolicDataAnalysisExpressionTracing.cs (modified) (8 diffs)
• Tracking/TraceCalculator.cs (added)

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

@@ -5 +5 @@
 TreeDistance
 SymbolicDataAnalysisExpressionTreeMatching.cs
+Importer

@@ -5 +5 @@
 TreeDistance
 SymbolicDataAnalysisExpressionTreeMatching.cs
+Importer

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs

@@ -26 +26 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
+
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableClass]
@@ -86 +88 @@
       var psi = new Psi();
       var sineIntegral = new SineIntegral();
+      var passthrough = new Passthrough();
 
       var @if = new IfThenElse();
@@ -113 +116 @@
       var exponentialAndLogarithmicSymbols = new GroupSymbol(ExponentialFunctionsName, new List<ISymbol> { exp, log });
       var specialFunctions = new GroupSymbol(SpecialFunctionsName, new List<ISymbol> { airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, 
-        fresnelCosineIntegral,fresnelSineIntegral,gamma,hypCosineIntegral,hypSineIntegral,norm, psi, sineIntegral});
+        fresnelCosineIntegral,fresnelSineIntegral,gamma,hypCosineIntegral,hypSineIntegral,norm, psi, sineIntegral, passthrough});
       var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, variableSymbol });
       var realValuedSymbols = new GroupSymbol(RealValuedSymbolsName, new List<ISymbol>() { arithmeticSymbols, trigonometricSymbols, exponentialAndLogarithmicSymbols, specialFunctions, terminalSymbols });
@@ -156 +159 @@
       SetSubtreeCount(laggedVariable, 0, 0);
       SetSubtreeCount(autoregressiveVariable, 0, 0);
+      SetSubtreeCount(passthrough, 1, 1);
       #endregion
 
@@ -224 +228 @@
       AddAllowedChildSymbol(derivative, powerSymbols);
       AddAllowedChildSymbol(derivative, conditionSymbols);
+
+      AddAllowedChildSymbol(passthrough, realValuedSymbols);
+      AddAllowedChildSymbol(passthrough, powerSymbols);
+      AddAllowedChildSymbol(passthrough, conditionSymbols);
+      AddAllowedChildSymbol(passthrough, timeSeriesSymbols);
+      AddAllowedChildSymbol(passthrough, specialFunctions);
       #endregion
     }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -105 +105 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Common-3.3">
+    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
       <Private>False</Private>
@@ -190 +191 @@
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionDiversityPreservingCrossover.cs" />
+    <Compile Include="Importer\SymbolicExpressionImporter.cs" />
+    <Compile Include="Importer\Token.cs" />
     <Compile Include="Interfaces\IModelBacktransformator.cs" />
-    <Compile Include="Interfaces\IDistanceCalculator.cs" />
+    <Compile Include="Interfaces\ISymbolicDataAnalysisExpressionSimilarityCalculator.cs" />
     <Compile Include="Matching\SymbolicExpressionTreeCanonicalSorter.cs" />
     <Compile Include="Matching\SymbolicExpressionTreeEqualityComparer.cs" />
@@ -263 +267 @@
     <Compile Include="Symbols\AiryB.cs" />
     <Compile Include="Symbols\Bessel.cs" />
+    <Compile Include="Symbols\Passthrough.cs" />
     <Compile Include="Symbols\Xor.cs" />
     <Compile Include="Symbols\Erf.cs" />
@@ -305 +310 @@
     <Compile Include="Symbols\VariableConditionTreeNode.cs" />
     <Compile Include="Symbols\VariableTreeNode.cs" />
+    <Compile Include="Tracking\TraceCalculator.cs" />
     <Compile Include="TransformationToSymbolicTreeMapper.cs" />
     <Compile Include="Tracking\FragmentGraph\FragmentGraph.cs" />
@@ -349 +355 @@
       <Project>{423bd94f-963a-438e-ba45-3bb3d61cd03b}</Project>
       <Name>HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views-3.4</Name>
+      <Private>False</Private>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.4\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj">

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisExpressionSimilarityCalculator.cs

@@ -1 @@
-using HeuristicLab.Core;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  public interface IDistanceCalculator : IItem {
-    double CalculateDistance(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2);
+  public interface ISymbolicDataAnalysisExpressionSimilarityCalculator : IItem {
+    double CalculateSimilarity(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2);
   }
 }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -83 +84 @@
     public const byte Erf = 43;
     public const byte Bessel = 44;
+    public const byte Passthrough = 45;
 
     private static Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
@@ -130 +132 @@
       { typeof(Norm), OpCodes.Norm},
       { typeof(Erf), OpCodes.Erf},
-      { typeof(Bessel), OpCodes.Bessel}   
+      { typeof(Bessel), OpCodes.Bessel},
+      { typeof(Passthrough), OpCodes.Passthrough}
     };
 

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs

@@ -111 +111 @@
 
       var code = SymbolicExpressionTreeLinearCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
+      PrepareInstructions(code, dataset);
+      return rows.Select(row => Evaluate(dataset, row, code));
+    }
+
+    // NOTE: do not use this method when evaluating trees. this method is provided as a shortcut for evaluating subtrees ad-hoc
+    public IEnumerable<double> GetValues(ISymbolicExpressionTreeNode node, Dataset dataset, IEnumerable<int> rows) {
+      var code = SymbolicExpressionTreeLinearCompiler.Compile(node, OpCodes.MapSymbolToOpCode);
       PrepareInstructions(code, dataset);
       return rows.Select(row => Evaluate(dataset, row, code));
@@ -329 +336 @@
           state.Reset();
           instr.value = interpreter.Evaluate(dataset, ref row, state);
+        } else if (instr.opCode == OpCodes.Passthrough) {
+          instr.value = code[instr.childIndex].value;
         } else {
           var errorText = string.Format("The {0} symbol is not supported by the linear interpreter. To support this symbol, please use the SymbolicDataAnalysisExpressionTreeInterpreter.", instr.dynamicNode.Symbol.Name);

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Matching/SymbolicExpressionTreeMatching.cs

@@ -77 +77 @@
 
     public static ISymbolicExpressionTreeNode Difference(this ISymbolicExpressionTreeNode node, ISymbolicExpressionTreeNode other) {
-      var these = node.IterateNodesPrefix().ToList();
-      var others = other.IterateNodesPrefix().ToList();
-
-      var minCount = Math.Min(these.Count, others.Count);
+      var a = node.IterateNodesPrefix().ToList();
+      var b = other.IterateNodesPrefix().ToList();
       var list = new List<ISymbolicExpressionTreeNode>();
-
-      for (int i = 0; i < minCount; ++i) {
-        if (these[i].ToString() != others[i].ToString())
-          list.Add(these[i]);
+      for (int i = 0, j = 0; i < a.Count && j < b.Count; ++i, ++j) {
+        var s1 = a[i].ToString();
+        var s2 = b[j].ToString();
+        if (s1 == s2) continue;
+        list.Add(a[i]);
+        // skip subtrees since the parents are already different
+        i += a[i].SubtreeCount;
+        j += b[j].SubtreeCount;
       }
-
-      return list.Count > 0 ? LowestCommonAncestor(node, list) : null;
+      ISymbolicExpressionTreeNode result = list.Count > 0 ? LowestCommonAncestor(node, list) : null;
+      return result;
     }
 
@@ -98 +100 @@
         return nodes[0];
 
-      int lowestLevel = nodes.Min(x => root.GetBranchLevel(x));
+      int minLevel = nodes.Min(x => root.GetBranchLevel(x));
 
       // bring the nodes in the nodes to the same level (relative to the root)
@@ -104 +106 @@
         var node = nodes[i];
         var level = root.GetBranchLevel(node);
-        for (int j = lowestLevel; j < level; ++j)
+        for (int j = minLevel; j < level; ++j)
           node = node.Parent;
         nodes[i] = node;

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SimilarityCalculators/BottomUpSimilarityCalculator.cs

@@ -32 +32 @@
   [StorableClass]
   [Item("BottomUpSimilarityCalculator", "A similarity calculator which uses the tree bottom-up distance as a similarity metric.")]
-  public class BottomUpSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
+  public class BottomUpSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator, ISymbolicDataAnalysisExpressionSimilarityCalculator {
     private readonly HashSet<string> commutativeSymbols = new HashSet<string> { "Addition", "Multiplication", "Average", "And", "Or", "Xor" };
 
@@ -39 +39 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       return new BottomUpSimilarityCalculator(this, cloner);
+    }
+
+    public double CalculateSimilarity(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2) {
+      if (t1 == t2)
+        return 1;
+
+      var map = ComputeBottomUpMapping(t1.Root, t2.Root);
+      return 2.0 * map.Count / (t1.Length + t2.Length);
     }
 
@@ -52 +60 @@
         throw new ArgumentException("Cannot calculate similarity when one of the arguments is null.");
 
-      var similarity = CalculateSolutionSimilarity(t1, t2);
+      var similarity = CalculateSimilarity(t1, t2);
       if (similarity > 1.0)
         throw new Exception("Similarity value cannot be greater than 1");
 
       return similarity;
-    }
-
-    public double CalculateSolutionSimilarity(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2) {
-      if (t1 == t2)
-        return 1;
-
-      var map = ComputeBottomUpMapping(t1.Root, t2.Root);
-      return 2.0 * map.Count / (t1.Length + t2.Length);
     }
 
@@ -174 +174 @@
         }
 
+        if (n == n1 || n == n2)
+          continue;
+
         var p = n.Parent;
         if (p == null)

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SimilarityCalculators/MaxCommonSubtreeSimilarityCalculator.cs

@@ -30 +30 @@
   [StorableClass]
   [Item("MaxCommonSubtreeSimilarityCalculator", "A similarity calculator based on the size of the maximum common subtree between two trees")]
-  public class MaxCommonSubtreeSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
-    public MaxCommonSubtreeSimilarityCalculator() { }
+  public class MaxCommonSubtreeSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator, ISymbolicDataAnalysisExpressionSimilarityCalculator {
+    private readonly SymbolicExpressionTreeNodeSimilarityComparer comparer;
+    public bool MatchVariableNames {
+      get { return comparer.MatchVariableNames; }
+      set { comparer.MatchVariableNames = value; }
+    }
+
+    public bool MatchVariableWeights {
+      get { return comparer.MatchVariableWeights; }
+      set { comparer.MatchVariableWeights = value; }
+    }
+
+    public bool MatchConstantValues {
+      get { return comparer.MatchConstantValues; }
+      set { comparer.MatchConstantValues = value; }
+    }
+
+    [StorableConstructor]
+    protected MaxCommonSubtreeSimilarityCalculator(bool deserializing) : base(deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MaxCommonSubtreeSimilarityCalculator(this, cloner);
+    }
 
     protected MaxCommonSubtreeSimilarityCalculator(MaxCommonSubtreeSimilarityCalculator original, Cloner cloner)
@@ -37 +58 @@
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MaxCommonSubtreeSimilarityCalculator(this, cloner);
+    public MaxCommonSubtreeSimilarityCalculator() {
+      comparer = new SymbolicExpressionTreeNodeSimilarityComparer {
+        MatchConstantValues = true,
+        MatchVariableNames = true,
+        MatchVariableWeights = true
+      };
+    }
+
+    public MaxCommonSubtreeSimilarityCalculator(bool matchVariableNames, bool matchVariableWeights, bool matchConstantValues) {
+      comparer = new SymbolicExpressionTreeNodeSimilarityComparer {
+        MatchConstantValues = matchConstantValues,
+        MatchVariableNames = matchVariableNames,
+        MatchVariableWeights = matchVariableWeights
+      };
+    }
+
+    public double CalculateSimilarity(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2) {
+      return MaxCommonSubtreeSimilarity(t1, t2, comparer);
     }
 
@@ -47 +84 @@
       if (t1 == null || t2 == null)
         throw new ArgumentException("Cannot calculate similarity when one of the arguments is null.");
-      var comparer = new SymbolicExpressionTreeNodeSimilarityComparer {
-        MatchConstantValues = true,
-        MatchVariableNames = true,
-        MatchVariableWeights = true
-      };
 
       return MaxCommonSubtreeSimilarity(t1, t2, comparer);

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SimilarityCalculators/PhenotypicSimilarityCalculator.cs

@@ -23 +23 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -29 +30 @@
   [Item("PhenotypicSimilarityCalculator", "An operator that calculates the similarity betweeon two trees based on the correlation of their outputs.")]
   [StorableClass]
-  public class PhenotypicSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
+  public class PhenotypicSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator, ISymbolicDataAnalysisExpressionSimilarityCalculator {
     public PhenotypicSimilarityCalculator(PhenotypicSimilarityCalculator original, Cloner cloner)
       : base(original, cloner) {
@@ -41 +42 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       return new PhenotypicSimilarityCalculator(this, cloner);
+    }
+
+    public double CalculateSimilarity(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2) {
+      throw new System.NotImplementedException();
     }
 

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionTracing.cs

@@ -48 +48 @@
       var parent = parentNode; // current parent
 
+      IGenealogyGraphNode<ISymbolicExpressionTree> n1 = null;
+      int i1 = -1;
+
       while (true) {
+        if (node == n1 && index == i1)
+          throw new InvalidOperationException("Infinite loop detected");
+
+        n1 = node;
+        i1 = index;
+
         if (!node.Parents.Any()) {
           // no tracing if there are no parents, return a fragment node representing the current trace
-          var fragmentNode = new FragmentNode(node) { SubtreeIndex = index };
+          var fragmentNode = new FragmentNode(node.Data) { SubtreeIndex = index };
           if (parent != null) {
-            var arc = new Arc(parent, fragmentNode);
+            var arc = new GenealogyGraphArc(parent, fragmentNode);
             parent.AddArc(arc);
             fragmentNode.AddArc(arc);
@@ -82 +91 @@
         if (parents.Count == 1) {
           // we are tracing a mutation operation
-          var fragmentNode = new FragmentNode(node) {
+          var fragmentNode = new FragmentNode(node.Data) {
             SubtreeIndex = index,
             FragmentIndex = fragment.Index1
@@ -91 +100 @@
             fragmentNode.AddArc(arc);
           }
+          if (node == parents[0])
+            throw new InvalidOperationException("Node == parents[0]");
+
           node = parents[0];
-          if (subtreeIndex == fragment.Index1) {
+
+          if (index == fragment.Index1) {
             // index stays the same
-          } else if (fragment.Index1 < subtreeIndex) {
-            if (subtreeIndex < fragment.Index1 + fragmentLength) {
+          } else if (fragment.Index1 < index) {
+            if (index < fragment.Index1 + fragmentLength) {
               // in the case of mutation, the fragment could have been introduced via a node replacement
               // there is no guarantee the subtree exists above this level, therefore the index is set to the fragment index
@@ -103 +116 @@
               index += node.Data.NodeAt(fragment.Index1).GetLength() - fragmentLength;
             }
-          } else if (subtreeIndex < fragment.Index1) {
-            if (fragment.Index1 < subtreeIndex + subtreeLength) {
+          } else if (index < fragment.Index1) {
+            if (fragment.Index1 < index + subtreeLength) {
               // subtree contains fragment
               index = fragment.Index1;
@@ -111 +124 @@
             }
           }
-
           yield return fragmentNode;
-          var up = Trace(node, index, fragmentNode); // force immediate query execution
+          if (node == graphNode && index == subtreeIndex)
+            throw new ArgumentException("Infinite recursion detected");
+          var up = Trace(node, index, fragmentNode).ToList(); // force immediate query execution
           foreach (var v in up) { yield return v; }
           break;
@@ -121 +135 @@
         #region crossover tracing
         if (parents.Count == 2) {
+          if (node == parents[0])
+            throw new InvalidOperationException("Node == parents[0]");
+          if (node == parents[1])
+            throw new InvalidOperationException("Node == parents[1]");
           // we are tracing a crossover operation
           if (fragment.Index1 == index) {
@@ -143 +161 @@
             if (fragment.Index1 < index + subtreeLength) {
               // subtree contains fragment => branching point in the fragment graph
-              var fragmentNode = new FragmentNode(node) {
+              var fragmentNode = new FragmentNode(node.Data) {
                 SubtreeIndex = index,
                 FragmentIndex = fragment.Index1
               };
               if (parent != null) {
-                var arc = new Arc(parent, fragmentNode);
+                var arc = new GenealogyGraphArc(parent, fragmentNode);
                 parent.AddArc(arc);
                 fragmentNode.AddArc(arc);
@@ -176 +194 @@
       return writer.ToString();
     }
-    #region some helper methods for shortening the tracing code
-    private static ISymbolicExpressionTreeNode NodeAt(this ISymbolicExpressionTree tree, int position) {
-      return NodeAt(tree.Root, position);
-    }
-    private static ISymbolicExpressionTreeNode NodeAt(this ISymbolicExpressionTreeNode root, int position) {
-      return root.IterateNodesPrefix().ElementAt(position);
-    }
-    #endregion
   }
 }

@@ -5 +5 @@
 TreeDistance
 SymbolicDataAnalysisExpressionTreeMatching.cs
+Importer