Changeset 10833 for branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

05/11/14 00:03:36 (10 years ago)

Author:

bburlacu

Message:

#1772: Fixed another minor display bug concerning elite individuals. Fixed bug when saving fragments from mutation. Displayed quality as well in the SymbolicExpressionTreeTile.

Location:

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

Files:

• Matching/SymbolicExpressionTreeMaxCommonSequenceCalculator.cs (modified) (3 diffs)
• Tracking/SymbolicDataAnalysisExpressionAfterCrossoverOperator.cs (modified) (1 diff)
• Tracking/SymbolicDataAnalysisExpressionAfterManipulatorOperator.cs (modified) (1 diff)
• Tracking/SymbolicDataAnalysisExpressionBeforeCrossoverOperator.cs (modified) (2 diffs)
• Tracking/SymbolicDataAnalysisExpressionBeforeManipulatorOperator.cs (modified) (1 diff)
• Tracking/SymbolicDataAnalysisExpressionTracing.cs (modified) (2 diffs)

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

@@ -1 @@
-using System;
+#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 System;
 using System.Collections.Generic;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Matching {
-  public class MaxCommonSequenceCalculator<T, U>
+  public class MaxCommonSequenceCalculator<T, TComp>
     where T : class
-    where U : IEqualityComparer<T> {
+    where TComp : IEqualityComparer<T> {
 
-    public U Comparer { get; set; }
+    private TComp comparer;
+    public TComp Comparer {
+      get { return comparer; }
+      set { comparer = value; }
+    }
+
     private int[,] matrix;
     private List<T> sequence;
 
+    public MaxCommonSequenceCalculator(TComp comparer) {
+      this.comparer = comparer;
+    }
+
     /// <summary>
-    /// Calculate the maximal common subsequence between arrays a and b and return it
+    /// Calculate the maximal common subsequence between arrays a and b and return it.
+    /// THIS DOES NOT WORK FOR TREES
     /// </summary>
     /// <param name="a"></param>
@@ -27 +58 @@
       for (int i = 0; i <= m; ++i) {
         for (int j = 0; j <= n; ++j) {
-          if (i == 0 || j == 0) {
-            matrix[i, j] = 0;
-          } else if (Comparer.Equals(a[i - 1], b[j - 1])) {
+          if (comparer.Equals(a[i - 1], b[j - 1])) {
             matrix[i, j] = matrix[i - 1, j - 1] + 1;
           } else {
@@ -36 +65 @@
         }
       }
-      recon(a, b, n, m);
+      Recon(a, b, n, m); // build the common subsequence
       return sequence;
     }
 
-    private void recon(T[] a, T[] b, int i, int j) {
-      while (true) {
-        if (i == 0 || j == 0) return;
-        if (Comparer.Equals(a[i - 1], b[j - 1])) {
-          recon(a, b, i - 1, j - 1);
+    private void Recon(T[] a, T[] b, int i, int j) {
+      while (i > 0 && j > 0) {
+        if (comparer.Equals(a[i - 1], b[j - 1])) {
+          Recon(a, b, i - 1, j - 1);
           sequence.Add(a[i - 1]);
         } else if (matrix[i - 1, j] > matrix[i, j - 1]) {

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

@@ -46 +46 @@
         break;
       }
-      //
-      //      if (fragment == null) {
-      //        throw new Exception("SymbolicDataAnalysisExpressionAfterCrossoverOperator: Could not identify fragment");
-      //      }
 
       arcs[0].Data = null;

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

@@ -57 +57 @@
       }
 
-      //      if (fragment == null) {
-      //        throw new Exception("SymbolicDataAnalysisExpressionAfterManipulatorOperator: Could not identify fragment");
-      //      }
-
       vChild.InArcs.First().Data = fragment;
       return base.Apply();

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

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Linq;
 using HeuristicLab.Core;
@@ -35 +34 @@
 
       for (int i = 0; i < parents.Count; ++i) {
-        var nodes = parents[i].IterateNodesPrefix().ToList();
-        arcs[i].Data = nodes;
+        arcs[i].Data = parents[i].IterateNodesPrefix().ToList();
       }
-      var parentVertices = childVertex.Parents.ToList();
-      if (parents[0].Length != parentVertices[0].Content.Length || parents[1].Length != parentVertices[1].Content.Length) {
-        throw new Exception("Inconsistency detected in GenealogyGraph.");
-      }
+
+      //      var parentVertices = childVertex.Parents.ToList();
+      //
+      //      if (parents[0].Length != parentVertices[0].Content.Length || parents[1].Length != parentVertices[1].Content.Length) {
+      //        throw new Exception("Inconsistency detected in GenealogyGraph.");
+      //      }
 
       return result;

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

@@ -33 +33 @@
       vChild.InArcs.First().Data = vChild.Content.IterateNodesPrefix().ToList();
 
+      var vClone = (IGenealogyGraphNode<ISymbolicExpressionTree>)vChild.InArcs.Last().Source;
+      var fragment = (IFragment<ISymbolicExpressionTreeNode>)vClone.InArcs.Last().Data;
+      if (fragment != null) {
+        // this step must be performed because the fragment root actually references the original child (not the clone). 
+        // then, a mutation operation (acting on the original child), could disrupt it
+        fragment.Root = vClone.Content.IterateNodesPrefix().ElementAt(fragment.Index1);
+      }
+
       return result;
     }

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

@@ -30 +30 @@
           var fragmentNode = new FragmentNode {
             Content = new Fragment<ISymbolicExpressionTreeNode> { Root = node.Content.NodeAt(index) },
-            Rank = node.Rank
+            Rank = node.Rank,
+            Quality = node.Quality
           };
           if (parent != null) {
@@ -98 +99 @@
               var fragmentNode = new FragmentNode {
                 Content = new Fragment<ISymbolicExpressionTreeNode> { Root = subtree },
-                Rank = node.Rank
+                Rank = node.Rank,
+                Quality = node.Quality
               };
               if (parent != null) {