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

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

Author: rcurtin
Date: Tue Jul 29 11:50:38 2014
New Revision: 16917

Log:
Don't do base cases before recursing.  This is slightly cleaner code and will
properly handle the case where the tree is only one node deep.


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	Tue Jul 29 11:50:38 2014
@@ -39,77 +39,65 @@
     BinarySpaceTree<BoundType, StatisticType, MatType, SplitType>&
         referenceNode)
 {
-  // If this is a leaf, the base cases have already been run.
+  // If we are a leaf, run the base case as necessary.
   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.Left()->Begin();
-         i < referenceNode.Left()->End(); ++i)
+    for (size_t i = referenceNode.Begin(); i < referenceNode.End(); ++i)
       rule.BaseCase(queryIndex, i);
   }
-
-  double rightScore = rule.Score(queryIndex, *referenceNode.Right());
-
-  // Immediately run the base case if it's not pruned.
-  if ((rightScore != DBL_MAX) && (referenceNode.Right()->IsLeaf()))
+  else
   {
-    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());
-
-    // 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;
-  }
-  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 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());
 
-    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 (leftScore < rightScore)
     {
-      // Choose the left first.
+      // Recurse to the left.
       Traverse(queryIndex, *referenceNode.Left());
 
       // Is it still valid to recurse to the right?
-      rightScore = rule.Rescore(queryIndex, *referenceNode.Right(),
-          rightScore);
+      rightScore = rule.Rescore(queryIndex, *referenceNode.Right(), rightScore);
 
       if (rightScore != DBL_MAX)
-        Traverse(queryIndex, *referenceNode.Right());
+        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
+      {
+        // 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;
+      }
+    }
   }
 }