[mlpack-git] mlpack-2.0.x: Replace lambdas by a comparator. (87e39fb)

gitdub at mlpack.org gitdub at mlpack.org
Wed Jul 20 15:28:40 EDT 2016


Repository : https://github.com/mlpack/mlpack
On branch  : mlpack-2.0.x
Link       : https://github.com/mlpack/mlpack/compare/e434bc4ac042534529a2a440a44d86935b4d7164...fc4195d27bb9e642356a384d1fa6fe10cbdf89a6

>---------------------------------------------------------------

commit 87e39fb16e9ca14370b9d8c2e23b9693486ecedf
Author: Mikhail Lozhnikov <lozhnikovma at gmail.com>
Date:   Tue Jul 12 16:56:43 2016 +0300

    Replace lambdas by a comparator.


>---------------------------------------------------------------

87e39fb16e9ca14370b9d8c2e23b9693486ecedf
 .../core/tree/rectangle_tree/r_star_tree_split.hpp | 11 +++++
 .../tree/rectangle_tree/r_star_tree_split_impl.hpp | 42 +++----------------
 .../core/tree/rectangle_tree/x_tree_split.hpp      | 11 +++++
 .../core/tree/rectangle_tree/x_tree_split_impl.hpp | 49 ++++------------------
 4 files changed, 35 insertions(+), 78 deletions(-)

diff --git a/src/mlpack/core/tree/rectangle_tree/r_star_tree_split.hpp b/src/mlpack/core/tree/rectangle_tree/r_star_tree_split.hpp
index a91cd87..801e77f 100644
--- a/src/mlpack/core/tree/rectangle_tree/r_star_tree_split.hpp
+++ b/src/mlpack/core/tree/rectangle_tree/r_star_tree_split.hpp
@@ -63,6 +63,17 @@ class RStarTreeSplit
    */
   template<typename Archive>
   void Serialize(Archive &, const unsigned int /* version */) { };
+
+  /**
+   * Comparator for sorting with std::pair. This comparator works a little bit
+   * faster then the default comparator.
+   */
+  template<typename ElemType>
+  static bool PairComp(const std::pair<ElemType, size_t>& p1,
+                       const std::pair<ElemType, size_t>& p2)
+  {
+    return p1.first < p2.first;
+  }
 };
 
 } // namespace tree
diff --git a/src/mlpack/core/tree/rectangle_tree/r_star_tree_split_impl.hpp b/src/mlpack/core/tree/rectangle_tree/r_star_tree_split_impl.hpp
index 2f5c008..d24ffdc 100644
--- a/src/mlpack/core/tree/rectangle_tree/r_star_tree_split_impl.hpp
+++ b/src/mlpack/core/tree/rectangle_tree/r_star_tree_split_impl.hpp
@@ -80,12 +80,7 @@ void RStarTreeSplit<TreeType>::SplitLeafNode(TreeType *tree,std::vector<bool>& r
       sorted[i].second = i;
     }
 
-    std::sort(sorted.begin(), sorted.end(),
-        [] (const std::pair<ElemType, size_t>& p1,
-            const std::pair<ElemType, size_t>& p2)
-        {
-          return p1.first < p2.first;
-        });
+    std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
     std::vector<size_t> pointIndices(p);
 
     for (size_t i = 0; i < p; i++)
@@ -122,12 +117,7 @@ void RStarTreeSplit<TreeType>::SplitLeafNode(TreeType *tree,std::vector<bool>& r
       sorted[i].second = i;
     }
 
-    std::sort(sorted.begin(), sorted.end(),
-        [] (const std::pair<ElemType, size_t>& p1,
-            const std::pair<ElemType, size_t>& p2)
-        {
-          return p1.first < p2.first;
-        });
+    std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
     // We'll store each of the three scores for each distribution.
     std::vector<ElemType> areas(tree->MaxLeafSize() - 2 * tree->MinLeafSize() +
@@ -206,12 +196,7 @@ void RStarTreeSplit<TreeType>::SplitLeafNode(TreeType *tree,std::vector<bool>& r
     sorted[i].second = i;
   }
 
-  std::sort(sorted.begin(), sorted.end(),
-      [] (const std::pair<ElemType, size_t>& p1,
-          const std::pair<ElemType, size_t>& p2)
-      {
-        return p1.first < p2.first;
-      });
+  std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
   TreeType* treeOne = new TreeType(tree->Parent());
   TreeType* treeTwo = new TreeType(tree->Parent());
@@ -372,12 +357,7 @@ bool RStarTreeSplit<TreeType>::SplitNonLeafNode(TreeType* tree,
       sorted[i].second = i;
     }
 
-    std::sort(sorted.begin(), sorted.end(),
-        [] (const std::pair<ElemType, size_t>& p1,
-            const std::pair<ElemType, size_t>& p2)
-        {
-          return p1.first < p2.first;
-        });
+    std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
     // We'll store each of the three scores for each distribution.
     std::vector<ElemType> areas(tree->MaxNumChildren() -
@@ -460,12 +440,7 @@ bool RStarTreeSplit<TreeType>::SplitNonLeafNode(TreeType* tree,
       sorted[i].second = i;
     }
 
-    std::sort(sorted.begin(), sorted.end(),
-        [] (const std::pair<ElemType, size_t>& p1,
-            const std::pair<ElemType, size_t>& p2)
-        {
-          return p1.first < p2.first;
-        });
+    std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
     // We'll store each of the three scores for each distribution.
     std::vector<ElemType> areas(tree->MaxNumChildren() -
@@ -556,12 +531,7 @@ bool RStarTreeSplit<TreeType>::SplitNonLeafNode(TreeType* tree,
     }
   }
 
-  std::sort(sorted.begin(), sorted.end(),
-      [] (const std::pair<ElemType, size_t>& p1,
-          const std::pair<ElemType, size_t>& p2)
-      {
-        return p1.first < p2.first;
-      });
+  std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
   TreeType* treeOne = new TreeType(tree->Parent());
   TreeType* treeTwo = new TreeType(tree->Parent());
diff --git a/src/mlpack/core/tree/rectangle_tree/x_tree_split.hpp b/src/mlpack/core/tree/rectangle_tree/x_tree_split.hpp
index e859b36..6544fc8 100644
--- a/src/mlpack/core/tree/rectangle_tree/x_tree_split.hpp
+++ b/src/mlpack/core/tree/rectangle_tree/x_tree_split.hpp
@@ -110,6 +110,17 @@ class XTreeSplit
    */
   template<typename Archive>
   void Serialize(Archive& ar, const unsigned int /* version */);
+
+  /**
+   * Comparator for sorting with std::pair. This comparator works a little bit
+   * faster then the default comparator.
+   */
+  template<typename ElemType>
+  static bool PairComp(const std::pair<ElemType, size_t>& p1,
+                       const std::pair<ElemType, size_t>& p2)
+  {
+    return p1.first < p2.first;
+  }
 };
 
 } // namespace tree
diff --git a/src/mlpack/core/tree/rectangle_tree/x_tree_split_impl.hpp b/src/mlpack/core/tree/rectangle_tree/x_tree_split_impl.hpp
index 2865fc5..15c849b 100644
--- a/src/mlpack/core/tree/rectangle_tree/x_tree_split_impl.hpp
+++ b/src/mlpack/core/tree/rectangle_tree/x_tree_split_impl.hpp
@@ -106,12 +106,7 @@ void XTreeSplit<TreeType>::SplitLeafNode(TreeType* tree,
       sorted[i].second = i;
     }
 
-    std::sort(sorted.begin(), sorted.end(),
-        [] (const std::pair<ElemType, size_t>& p1,
-            const std::pair<ElemType, size_t>& p2)
-        {
-          return p1.first < p2.first;
-        });
+    std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
     std::vector<size_t> pointIndices(p);
 
     for (size_t i = 0; i < p; i++)
@@ -158,12 +153,7 @@ void XTreeSplit<TreeType>::SplitLeafNode(TreeType* tree,
       sorted[i].second = i;
     }
 
-    std::sort(sorted.begin(), sorted.end(),
-        [] (const std::pair<ElemType, size_t>& p1,
-            const std::pair<ElemType, size_t>& p2)
-        {
-          return p1.first < p2.first;
-        });
+    std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
     // We'll store each of the three scores for each distribution.
     std::vector<ElemType> areas(tree->MaxLeafSize() -
@@ -239,12 +229,7 @@ void XTreeSplit<TreeType>::SplitLeafNode(TreeType* tree,
     sorted[i].second = i;
   }
 
-  std::sort(sorted.begin(), sorted.end(),
-        [] (const std::pair<ElemType, size_t>& p1,
-            const std::pair<ElemType, size_t>& p2)
-        {
-          return p1.first < p2.first;
-        });
+  std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
   TreeType* treeOne = new TreeType(tree->Parent(), NormalNodeMaxNumChildren());
   TreeType* treeTwo = new TreeType(tree->Parent(), NormalNodeMaxNumChildren());
@@ -415,12 +400,7 @@ bool XTreeSplit<TreeType>::SplitNonLeafNode(TreeType* tree,
       sorted[i].second = i;
     }
 
-    std::sort(sorted.begin(), sorted.end(),
-        [] (const std::pair<ElemType, size_t>& p1,
-            const std::pair<ElemType, size_t>& p2)
-        {
-          return p1.first < p2.first;
-        });
+    std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
     // We'll store each of the three scores for each distribution.
     std::vector<ElemType> areas(tree->MaxNumChildren() -
@@ -525,12 +505,7 @@ bool XTreeSplit<TreeType>::SplitNonLeafNode(TreeType* tree,
       sorted[i].second = i;
     }
 
-    std::sort(sorted.begin(), sorted.end(),
-        [] (const std::pair<ElemType, size_t>& p1,
-            const std::pair<ElemType, size_t>& p2)
-        {
-          return p1.first < p2.first;
-        });
+    std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
     // We'll store each of the three scores for each distribution.
     std::vector<ElemType> areas(tree->MaxNumChildren() -
@@ -644,12 +619,7 @@ bool XTreeSplit<TreeType>::SplitNonLeafNode(TreeType* tree,
     }
   }
 
-  std::sort(sorted.begin(), sorted.end(),
-      [] (const std::pair<ElemType, size_t>& p1,
-          const std::pair<ElemType, size_t>& p2)
-      {
-        return p1.first < p2.first;
-      });
+  std::sort(sorted.begin(), sorted.end(), PairComp<ElemType>);
 
   TreeType* treeOne = new TreeType(tree->Parent(), tree->MaxNumChildren());
   TreeType* treeTwo = new TreeType(tree->Parent(), tree->MaxNumChildren());
@@ -713,12 +683,7 @@ bool XTreeSplit<TreeType>::SplitNonLeafNode(TreeType* tree,
           sorted2[i].second = i;
         }
       }
-      std::sort(sorted2.begin(), sorted2.end(),
-          [] (const std::pair<ElemType, size_t>& p1,
-              const std::pair<ElemType, size_t>& p2)
-          {
-            return p1.first < p2.first;
-          });
+      std::sort(sorted2.begin(), sorted2.end(), PairComp<ElemType>);
 
       for (size_t i = 0; i < tree->NumChildren(); i++)
       {




More information about the mlpack-git mailing list