[mlpack] 22/324: Ensure that BaseCase() is called right after a node is scored.

[Barak A. Pearlmutter]

This is an automated email from the git hooks/post-receive script.

bap pushed a commit to branch svn-trunk
in repository mlpack.

commit 57e739afb91dfa42e5422d6626159cc545674525
Author: rcurtin <rcurtin at 9d5b8971-822b-0410-80eb-d18c1038ef23>
Date:   Tue May 27 00:31:47 2014 +0000

    Ensure that BaseCase() is called right after a node is scored.
    
    
    git-svn-id: http://svn.cc.gatech.edu/fastlab/mlpack/trunk@16553 9d5b8971-822b-0410-80eb-d18c1038ef23
---
 .../single_tree_traverser_impl.hpp                 | 100 ++++++++++++---------
 1 file changed, 56 insertions(+), 44 deletions(-)

diff --git a/src/mlpack/core/tree/binary_space_tree/single_tree_traverser_impl.hpp b/src/mlpack/core/tree/binary_space_tree/single_tree_traverser_impl.hpp
index 7b559e0..0a1e71f 100644
--- a/src/mlpack/core/tree/binary_space_tree/single_tree_traverser_impl.hpp
+++ b/src/mlpack/core/tree/binary_space_tree/single_tree_traverser_impl.hpp
@@ -39,65 +39,77 @@ SingleTreeTraverser<RuleType>::Traverse(
     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;
-      }
-    }
   }
 }
 

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/mlpack.git