Index: anches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAnalyser.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAnalyser.cs	(revision 5555)
+++ 	(revision )
@@ -1,69 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 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 System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  /// <summary>
-  /// Abstract base class symbolic data analysis analyzers.
-  /// </summary>
-  [StorableClass]
-  public abstract class SymbolicDataAnalysisAnalyzer : SingleSuccessorOperator, ISymbolicDataAnalysisAnalyzer {
-    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
-    private const string ResultCollectionParameterName = "Results";
-
-    #region parameter properties
-    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
-      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
-    }
-    public ILookupParameter<ResultCollection> ResultCollectionParameter {
-      get { return (ILookupParameter<ResultCollection>)Parameters[ResultCollectionParameterName]; }
-    }
-    #endregion
-    #region properties
-    public ItemArray<ISymbolicExpressionTree> SymbolicExpressionTrees {
-      get { return SymbolicExpressionTreeParameter.ActualValue; }
-    }
-    public ResultCollection ResultCollection {
-      get { return ResultCollectionParameter.ActualValue; }
-    }
-    #endregion
-    [StorableConstructor]
-    protected SymbolicDataAnalysisAnalyzer(bool deserializing) : base(deserializing) { }
-    protected SymbolicDataAnalysisAnalyzer(VariableFrequencyAnalyser original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public SymbolicDataAnalysisAnalyzer()
-      : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees that should be analyzed."));
-      Parameters.Add(new LookupParameter<ResultCollection>(ResultCollectionParameterName, "The result collection to store the analysis results."));
-    }
-  }
-}
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAnalyzer.cs	(revision 5556)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAnalyzer.cs	(revision 5556)
@@ -0,0 +1,69 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  /// <summary>
+  /// Abstract base class symbolic data analysis analyzers.
+  /// </summary>
+  [StorableClass]
+  public abstract class SymbolicDataAnalysisAnalyzer : SingleSuccessorOperator, ISymbolicDataAnalysisAnalyzer {
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string ResultCollectionParameterName = "Results";
+
+    #region parameter properties
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public ILookupParameter<ResultCollection> ResultCollectionParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters[ResultCollectionParameterName]; }
+    }
+    #endregion
+    #region properties
+    public ItemArray<ISymbolicExpressionTree> SymbolicExpressionTrees {
+      get { return SymbolicExpressionTreeParameter.ActualValue; }
+    }
+    public ResultCollection ResultCollection {
+      get { return ResultCollectionParameter.ActualValue; }
+    }
+    #endregion
+    [StorableConstructor]
+    protected SymbolicDataAnalysisAnalyzer(bool deserializing) : base(deserializing) { }
+    protected SymbolicDataAnalysisAnalyzer(SymbolicDataAnalysisAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public SymbolicDataAnalysisAnalyzer()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees that should be analyzed."));
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultCollectionParameterName, "The result collection to store the analysis results."));
+    }
+  }
+}
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisVariableFrequencyAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisVariableFrequencyAnalyzer.cs	(revision 5556)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisVariableFrequencyAnalyzer.cs	(revision 5556)
@@ -0,0 +1,178 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Analysis;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  /// <summary>
+  /// Calculates the accumulated frequencies of variable-symbols over all trees in the population.
+  /// </summary>
+  [Item("SymbolicDataAnalysisVariableFrequencyAnalyzer", "Calculates the accumulated frequencies of variable-symbols over all trees in the population.")]
+  [StorableClass]
+  public sealed class SymbolicDataAnalysisVariableFrequencyAnalyzer : SymbolicDataAnalysisAnalyzer {
+    private const string VariableFrequenciesParameterName = "VariableFrequencies";
+    private const string AggregateLaggedVariablesParameterName = "AggregateLaggedVariables";
+
+    #region parameter properties
+    public ILookupParameter<DataTable> VariableFrequenciesParameter {
+      get { return (ILookupParameter<DataTable>)Parameters[VariableFrequenciesParameterName]; }
+    }
+    public IValueLookupParameter<BoolValue> AggregateLaggedVariablesParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters[AggregateLaggedVariablesParameterName]; }
+    }
+    #endregion
+    #region properties
+    public DataTable VariableFrequencies {
+      get { return VariableFrequenciesParameter.ActualValue; }
+      set { VariableFrequenciesParameter.ActualValue = value; }
+    }
+    public BoolValue AggregateLaggedVariables {
+      get { return AggregateLaggedVariablesParameter.ActualValue; }
+    }
+    #endregion
+    [StorableConstructor]
+    private SymbolicDataAnalysisVariableFrequencyAnalyzer(bool deserializing) : base(deserializing) { }
+    private SymbolicDataAnalysisVariableFrequencyAnalyzer(SymbolicDataAnalysisVariableFrequencyAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public SymbolicDataAnalysisVariableFrequencyAnalyzer()
+      : base() {
+      Parameters.Add(new LookupParameter<DataTable>(VariableFrequenciesParameterName, "The relative variable reference frequencies aggregated over all trees in the population."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>(AggregateLaggedVariablesParameterName, "Switch that determines whether all references to a variable should be aggregated regardless of time-offsets. Turn off to analyze all variable references with different time offsets separately.", new BoolValue(true)));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicDataAnalysisVariableFrequencyAnalyzer(this, cloner);
+    }
+
+
+    public override IOperation Apply() {
+      ItemArray<ISymbolicExpressionTree> expressions = SymbolicExpressionTreeParameter.ActualValue;
+      ResultCollection results = ResultCollection;
+
+      if (VariableFrequencies == null) {
+        VariableFrequencies = new DataTable("Variable frequencies", "Relative frequency of variable references aggregated over the whole population.");
+        VariableFrequencies.VisualProperties.XAxisTitle = "Generation";
+        VariableFrequencies.VisualProperties.YAxisTitle = "Relative Variable Frequency";
+        results.Add(new Result("Variable frequencies", VariableFrequencies));
+      }
+
+      // all rows must have the same number of values so we can just take the first
+      int numberOfValues = VariableFrequencies.Rows.Select(r => r.Values.Count).DefaultIfEmpty().First();
+
+      foreach (var pair in SymbolicDataAnalysisVariableFrequencyAnalyzer.CalculateVariableFrequencies(expressions, AggregateLaggedVariables.Value)) {
+        if (!VariableFrequencies.Rows.ContainsKey(pair.Key)) {
+          // initialize a new row for the variable and pad with zeros
+          DataRow row = new DataRow(pair.Key, "", Enumerable.Repeat(0.0, numberOfValues));
+          row.VisualProperties.StartIndexZero = true;
+          VariableFrequencies.Rows.Add(row);
+        }
+        VariableFrequencies.Rows[pair.Key].Values.Add(pair.Value);
+      }
+
+      // add a zero for each data row that was not modified in the previous loop 
+      foreach (var row in VariableFrequencies.Rows.Where(r => r.Values.Count != numberOfValues + 1))
+        row.Values.Add(0.0);
+
+      return base.Apply();
+    }
+
+    public static IEnumerable<KeyValuePair<string, double>> CalculateVariableFrequencies(IEnumerable<ISymbolicExpressionTree> trees, bool aggregateLaggedVariables = true) {
+      Dictionary<string, double> variableFrequencies = new Dictionary<string, double>();
+      int totalNumberOfSymbols = 0;
+
+      foreach (var tree in trees) {
+        var variableReferences = GetVariableReferences(tree, aggregateLaggedVariables);
+        foreach (var pair in variableReferences) {
+          totalNumberOfSymbols += pair.Value;
+        }
+      }
+
+      foreach (var pair in variableFrequencies)
+        yield return new KeyValuePair<string, double>(pair.Key, pair.Value / totalNumberOfSymbols);
+    }
+
+    private static IEnumerable<KeyValuePair<string, int>> GetVariableReferences(ISymbolicExpressionTree tree, bool aggregateLaggedVariables = true) {
+      Dictionary<string, int> references = new Dictionary<string, int>();
+      if (aggregateLaggedVariables) {
+        tree.Root.ForEachNodePrefix(node => {
+          if (node.Symbol is Variable) {
+            var varNode = node as VariableTreeNode;
+            IncReferenceCount(references, varNode.VariableName);
+          } else if (node.Symbol is VariableCondition) {
+            var varCondNode = node as VariableConditionTreeNode;
+            IncReferenceCount(references, varCondNode.VariableName);
+          }
+        });
+      } else {
+        GetVariableReferences(references, tree.Root, 0);
+      }
+      return references;
+    }
+
+    private static void GetVariableReferences(Dictionary<string, int> references, ISymbolicExpressionTreeNode node, int currentLag) {
+      if (node.Symbol is LaggedVariable) {
+        var laggedVarNode = node as LaggedVariableTreeNode;
+        IncReferenceCount(references, laggedVarNode.VariableName, currentLag + laggedVarNode.Lag);
+      } else if (node.Symbol is Variable) {
+        var varNode = node as VariableTreeNode;
+        IncReferenceCount(references, varNode.VariableName, currentLag);
+      } else if (node.Symbol is VariableCondition) {
+        var varCondNode = node as VariableConditionTreeNode;
+        IncReferenceCount(references, varCondNode.VariableName, currentLag);
+        GetVariableReferences(references, node.GetSubTree(0), currentLag);
+        GetVariableReferences(references, node.GetSubTree(1), currentLag);
+      } else if (node.Symbol is Integral) {
+        var laggedNode = node as LaggedTreeNode;
+        for (int l = laggedNode.Lag; l <= 0; l++) {
+          GetVariableReferences(references, node.GetSubTree(0), currentLag + l);
+        }
+      } else if (node.Symbol is Derivative) {
+        var laggedNode = node as LaggedTreeNode;
+        for (int l = laggedNode.Lag; l <= 0; l++) {
+          GetVariableReferences(references, node.GetSubTree(0), currentLag + l);
+        }
+      } else if (node.Symbol is TimeLag) {
+        var laggedNode = node as LaggedTreeNode;
+        GetVariableReferences(references, node.GetSubTree(0), currentLag + laggedNode.Lag);
+      }
+    }
+
+    private static void IncReferenceCount(Dictionary<string, int> references, string variableName, int timeLag = 0) {
+      string referenceId = variableName +
+        (timeLag == 0 ? "" : timeLag < 0 ? "(t" + timeLag + ")" : "(t+" + timeLag + ")");
+      if (references.ContainsKey(referenceId)) {
+        references[referenceId]++;
+      } else {
+        references[referenceId] = 1;
+      }
+    }
+  }
+}
Index: anches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/VariableFrequencyAnalyser.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/VariableFrequencyAnalyser.cs	(revision 5555)
+++ 	(revision )
@@ -1,178 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 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 System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Analysis;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  /// <summary>
-  /// Calculates the accumulated frequencies of variable-symbols over all trees in the population.
-  /// </summary>
-  [Item("VariableFrequencyAnalyser", "Calculates the accumulated frequencies of variable-symbols over all trees in the population.")]
-  [StorableClass]
-  public sealed class VariableFrequencyAnalyser : SymbolicDataAnalysisAnalyzer {
-    private const string VariableFrequenciesParameterName = "VariableFrequencies";
-    private const string AggregateLaggedVariablesParameterName = "AggregateLaggedVariables";
-
-    #region parameter properties
-    public ILookupParameter<DataTable> VariableFrequenciesParameter {
-      get { return (ILookupParameter<DataTable>)Parameters[VariableFrequenciesParameterName]; }
-    }
-    public IValueLookupParameter<BoolValue> AggregateLaggedVariablesParameter {
-      get { return (IValueLookupParameter<BoolValue>)Parameters[AggregateLaggedVariablesParameterName]; }
-    }
-    #endregion
-    #region properties
-    public DataTable VariableFrequencies {
-      get { return VariableFrequenciesParameter.ActualValue; }
-      set { VariableFrequenciesParameter.ActualValue = value; }
-    }
-    public BoolValue AggregateLaggedVariables {
-      get { return AggregateLaggedVariablesParameter.ActualValue; }
-    }
-    #endregion
-    [StorableConstructor]
-    private VariableFrequencyAnalyser(bool deserializing) : base(deserializing) { }
-    private VariableFrequencyAnalyser(VariableFrequencyAnalyser original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public VariableFrequencyAnalyser()
-      : base() {
-      Parameters.Add(new LookupParameter<DataTable>(VariableFrequenciesParameterName, "The relative variable reference frequencies aggregated over all trees in the population."));
-      Parameters.Add(new ValueLookupParameter<BoolValue>(AggregateLaggedVariablesParameterName, "Switch that determines whether all references to a variable should be aggregated regardless of time-offsets. Turn off to analyze all variable references with different time offsets separately.", new BoolValue(true)));
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new VariableFrequencyAnalyser(this, cloner);
-    }
-
-
-    public override IOperation Apply() {
-      ItemArray<ISymbolicExpressionTree> expressions = SymbolicExpressionTreeParameter.ActualValue;
-      ResultCollection results = ResultCollection;
-
-      if (VariableFrequencies == null) {
-        VariableFrequencies = new DataTable("Variable frequencies", "Relative frequency of variable references aggregated over the whole population.");
-        VariableFrequencies.VisualProperties.XAxisTitle = "Generation";
-        VariableFrequencies.VisualProperties.YAxisTitle = "Relative Variable Frequency";
-        results.Add(new Result("Variable frequencies", VariableFrequencies));
-      }
-
-      // all rows must have the same number of values so we can just take the first
-      int numberOfValues = VariableFrequencies.Rows.Select(r => r.Values.Count).DefaultIfEmpty().First();
-
-      foreach (var pair in VariableFrequencyAnalyser.CalculateVariableFrequencies(expressions, AggregateLaggedVariables.Value)) {
-        if (!VariableFrequencies.Rows.ContainsKey(pair.Key)) {
-          // initialize a new row for the variable and pad with zeros
-          DataRow row = new DataRow(pair.Key, "", Enumerable.Repeat(0.0, numberOfValues));
-          row.VisualProperties.StartIndexZero = true;
-          VariableFrequencies.Rows.Add(row);
-        }
-        VariableFrequencies.Rows[pair.Key].Values.Add(pair.Value);
-      }
-
-      // add a zero for each data row that was not modified in the previous loop 
-      foreach (var row in VariableFrequencies.Rows.Where(r => r.Values.Count != numberOfValues + 1))
-        row.Values.Add(0.0);
-
-      return base.Apply();
-    }
-
-    public static IEnumerable<KeyValuePair<string, double>> CalculateVariableFrequencies(IEnumerable<ISymbolicExpressionTree> trees, bool aggregateLaggedVariables = true) {
-      Dictionary<string, double> variableFrequencies = new Dictionary<string, double>();
-      int totalNumberOfSymbols = 0;
-
-      foreach (var tree in trees) {
-        var variableReferences = GetVariableReferences(tree, aggregateLaggedVariables);
-        foreach (var pair in variableReferences) {
-          totalNumberOfSymbols += pair.Value;
-        }
-      }
-
-      foreach (var pair in variableFrequencies)
-        yield return new KeyValuePair<string, double>(pair.Key, pair.Value / totalNumberOfSymbols);
-    }
-
-    private static IEnumerable<KeyValuePair<string, int>> GetVariableReferences(ISymbolicExpressionTree tree, bool aggregateLaggedVariables = true) {
-      Dictionary<string, int> references = new Dictionary<string, int>();
-      if (aggregateLaggedVariables) {
-        tree.Root.ForEachNodePrefix(node => {
-          if (node.Symbol is Variable) {
-            var varNode = node as VariableTreeNode;
-            IncReferenceCount(references, varNode.VariableName);
-          } else if (node.Symbol is VariableCondition) {
-            var varCondNode = node as VariableConditionTreeNode;
-            IncReferenceCount(references, varCondNode.VariableName);
-          }
-        });
-      } else {
-        GetVariableReferences(references, tree.Root, 0);
-      }
-      return references;
-    }
-
-    private static void GetVariableReferences(Dictionary<string, int> references, ISymbolicExpressionTreeNode node, int currentLag) {
-      if (node.Symbol is LaggedVariable) {
-        var laggedVarNode = node as LaggedVariableTreeNode;
-        IncReferenceCount(references, laggedVarNode.VariableName, currentLag + laggedVarNode.Lag);
-      } else if (node.Symbol is Variable) {
-        var varNode = node as VariableTreeNode;
-        IncReferenceCount(references, varNode.VariableName, currentLag);
-      } else if (node.Symbol is VariableCondition) {
-        var varCondNode = node as VariableConditionTreeNode;
-        IncReferenceCount(references, varCondNode.VariableName, currentLag);
-        GetVariableReferences(references, node.GetSubTree(0), currentLag);
-        GetVariableReferences(references, node.GetSubTree(1), currentLag);
-      } else if (node.Symbol is Integral) {
-        var laggedNode = node as LaggedTreeNode;
-        for (int l = laggedNode.Lag; l <= 0; l++) {
-          GetVariableReferences(references, node.GetSubTree(0), currentLag + l);
-        }
-      } else if (node.Symbol is Derivative) {
-        var laggedNode = node as LaggedTreeNode;
-        for (int l = laggedNode.Lag; l <= 0; l++) {
-          GetVariableReferences(references, node.GetSubTree(0), currentLag + l);
-        }
-      } else if (node.Symbol is TimeLag) {
-        var laggedNode = node as LaggedTreeNode;
-        GetVariableReferences(references, node.GetSubTree(0), currentLag + laggedNode.Lag);
-      }
-    }
-
-    private static void IncReferenceCount(Dictionary<string, int> references, string variableName, int timeLag = 0) {
-      string referenceId = variableName +
-        (timeLag == 0 ? "" : timeLag < 0 ? "(t" + timeLag + ")" : "(t+" + timeLag + ")");
-      if (references.ContainsKey(referenceId)) {
-        references[referenceId]++;
-      } else {
-        references[referenceId] = 1;
-      }
-    }
-  }
-}
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 5555)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 5556)
@@ -108,6 +108,6 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Analyzers\SymbolicDataAnalysisAnalyser.cs" />
-    <Compile Include="Analyzers\VariableFrequencyAnalyser.cs" />
+    <Compile Include="Analyzers\SymbolicDataAnalysisAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicDataAnalysisVariableFrequencyAnalyzer.cs" />
     <Compile Include="Interfaces\ISymbolicDataAnalysisValidatingAnalyzer.cs" />
     <Compile Include="Interfaces\ISymbolicDataAnalysisAnalyzer.cs" />
