[mlpack-svn] r16553 - mlpack/trunk/src/mlpack/core/tree/binary_space_tree

[fastlab-svn at coffeetalk-1.cc.gatech.edu]

Author: rcurtin
Date: Mon May 26 20:31:47 2014
New Revision: 16553

Log:
Ensure that BaseCase() is called right after a node is scored.


Modified:
   mlpack/trunk/src/mlpack/core/tree/binary_space_tree/single_tree_traverser_impl.hpp

Modified: mlpack/trunk/src/mlpack/core/tree/binary_space_tree/single_tree_traverser_impl.hpp
==============================================================================
--- mlpack/trunk/src/mlpack/core/tree/binary_space_tree/single_tree_traverser_impl.hpp	(original)
+++ mlpack/trunk/src/mlpack/core/tree/binary_space_tree/single_tree_traverser_impl.hpp	Mon May 26 20:31:47 2014
@@ -39,65 +39,77 @@
     BinarySpaceTree<BoundType, StatisticType, MatType, SplitType>&
         referenceNode)
 {
-  // If we are a leaf, run the base case as necessary.
+  // If this is a leaf, the base cases have already been run.
   if (referenceNode.IsLeaf())
+    return;
+
+  // If either score is DBL_MAX, we do not recurse into that node.
+  double leftScore = rule.Score(queryIndex, *referenceNode.Left());
+
+  // Immediately run the base case if it's not pruned.
+  if ((leftScore != DBL_MAX) && (referenceNode.Left()->IsLeaf()))
   {
-    for (size_t i = referenceNode.Begin(); i < referenceNode.End(); ++i)
+    for (size_t i = referenceNode.Left()->Begin();
+         i < referenceNode.Left()->End(); ++i)
       rule.BaseCase(queryIndex, i);
   }
-  else
+
+  double rightScore = rule.Score(queryIndex, *referenceNode.Right());
+
+  // Immediately run the base case if it's not pruned.
+  if ((rightScore != DBL_MAX) && (referenceNode.Right()->IsLeaf()))
   {
-    // If either score is DBL_MAX, we do not recurse into that node.
-    double leftScore = rule.Score(queryIndex, *referenceNode.Left());
-    double rightScore = rule.Score(queryIndex, *referenceNode.Right());
+    for (size_t i = referenceNode.Right()->Begin();
+         i < referenceNode.Right()->End(); ++i)
+      rule.BaseCase(queryIndex, i);
+  }
 
-    if (leftScore < rightScore)
-    {
-      // Recurse to the left.
-      Traverse(queryIndex, *referenceNode.Left());
+  if (leftScore < rightScore)
+  {
+    // Recurse to the left.
+    Traverse(queryIndex, *referenceNode.Left());
 
-      // Is it still valid to recurse to the right?
-      rightScore = rule.Rescore(queryIndex, *referenceNode.Right(), rightScore);
+    // Is it still valid to recurse to the right?
+    rightScore = rule.Rescore(queryIndex, *referenceNode.Right(), rightScore);
 
-      if (rightScore != DBL_MAX)
-        Traverse(queryIndex, *referenceNode.Right()); // Recurse to the right.
-      else
-        ++numPrunes;
+    if (rightScore != DBL_MAX)
+      Traverse(queryIndex, *referenceNode.Right()); // Recurse to the right.
+    else
+      ++numPrunes;
+  }
+  else if (rightScore < leftScore)
+  {
+    // Recurse to the right.
+    Traverse(queryIndex, *referenceNode.Right());
+
+    // Is it still valid to recurse to the left?
+    leftScore = rule.Rescore(queryIndex, *referenceNode.Left(), leftScore);
+
+    if (leftScore != DBL_MAX)
+      Traverse(queryIndex, *referenceNode.Left()); // Recurse to the left.
+    else
+      ++numPrunes;
+  }
+  else // leftScore is equal to rightScore.
+  {
+    if (leftScore == DBL_MAX)
+    {
+      numPrunes += 2; // Pruned both left and right.
     }
-    else if (rightScore < leftScore)
+    else
     {
-      // Recurse to the right.
-      Traverse(queryIndex, *referenceNode.Right());
+      // Choose the left first.
+      Traverse(queryIndex, *referenceNode.Left());
 
-      // Is it still valid to recurse to the left?
-      leftScore = rule.Rescore(queryIndex, *referenceNode.Left(), leftScore);
+      // Is it still valid to recurse to the right?
+      rightScore = rule.Rescore(queryIndex, *referenceNode.Right(),
+          rightScore);
 
-      if (leftScore != DBL_MAX)
-        Traverse(queryIndex, *referenceNode.Left()); // Recurse to the left.
+      if (rightScore != DBL_MAX)
+        Traverse(queryIndex, *referenceNode.Right());
       else
         ++numPrunes;
     }
-    else // leftScore is equal to rightScore.
-    {
-      if (leftScore == DBL_MAX)
-      {
-        numPrunes += 2; // Pruned both left and right.
-      }
-      else
-      {
-        // Choose the left first.
-        Traverse(queryIndex, *referenceNode.Left());
-
-        // Is it still valid to recurse to the right?
-        rightScore = rule.Rescore(queryIndex, *referenceNode.Right(),
-            rightScore);
-
-        if (rightScore != DBL_MAX)
-          Traverse(queryIndex, *referenceNode.Right());
-        else
-          ++numPrunes;
-      }
-    }
   }
 }