Sort behaves like R's 'sort(..., na.last=TRUE)'

Author: kevinushey

inst/include/Rcpp/sugar/functions/table.h

@@ -22,8 +22,6 @@
 #ifndef Rcpp__sugar__table_h
 #define Rcpp__sugar__table_h
 
-#include <Rcpp/sugar/tools/mapcompare.h>
-          
 namespace Rcpp{
 namespace sugar{
 
@@ -80,7 +78,7 @@ class Table {
     }
 
 private:
-    typedef RCPP_UNORDERED_MAP<STORAGE, int, MapCompare<STORAGE> >HASH ;
+    typedef RCPP_UNORDERED_MAP<STORAGE, int, ::Rcpp::traits::comparator_type<STORAGE> >HASH ;
     typedef CountInserter<HASH,STORAGE> Inserter ;
     HASH hash ;
 };
@@ -115,7 +113,7 @@ class Table {
     typedef CountInserter<HASH,STORAGE> Inserter ;
     HASH hash ;
 
-    typedef std::map<STORAGE, int, MapCompare<STORAGE> > SORTED_MAP ;
+    typedef std::map<STORAGE, int, ::Rcpp::traits::comparator_type<STORAGE> > SORTED_MAP ;
     SORTED_MAP map ;
 
 }; 

inst/include/Rcpp/sugar/tools/mapcompare.h

@@ -3,7 +3,7 @@
 //
 // comparator_type.h: Rcpp R/C++ interface class library -- comparator
 //
-// Copyright (C) 2012 Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2012-2014 Dirk Eddelbuettel, Romain Francois and Kevin Ushey
 //
 // This file is part of Rcpp.
 //
@@ -26,20 +26,72 @@
 namespace Rcpp{
 namespace traits{
 
-class StringCompare {
-public:
-    inline bool operator()( SEXP x, SEXP y) const {
-        return strcmp( char_nocheck(x), char_nocheck(y) ) < 0 ; 
+inline bool Rcpp_IsNA(double x) {
+  return memcmp(
+    &x,
+    &NA_REAL,
+    sizeof(double)
+  ) == 0;
+}
+
+inline bool Rcpp_IsNaN(double x) {
+  return memcmp(
+    &x,
+    &R_NaN,
+    sizeof(double)
+  ) == 0;
+}
+
+inline int StrCmp(SEXP x, SEXP y) {
+    if (x == NA_STRING) return (y == NA_STRING ? 0 : 1);
+    if (y == NA_STRING) return -1;
+    if (x == y) return 0;  // same string in cache
+    return strcmp(CHAR(x), CHAR(y));
+}
+
+template <typename T>
+struct comparator_type {
+  inline bool operator()(T left, T right) const {
+    return left < right;
+  }
+};
+
+template <>
+struct comparator_type<int> {
+  inline bool operator()(int left, int right) const {
+    if (left == NA_INTEGER) return false;
+    if (right == NA_INTEGER) return true;
+    return left < right;
+  }
+};
+
+template <>
+struct comparator_type<double> {  
+  inline bool operator()(double left, double right) const {
+        
+    bool leftNaN = (left != left);
+    bool rightNaN = (right != right);
+    
+    // this branch inspired by data.table: see
+    // https://github.com/arunsrinivasan/datatable/commit/1a3e476d3f746e18261662f484d2afa84ac7a146#commitcomment-4885242
+    if (Rcpp_IsNaN(right) and Rcpp_IsNA(left)) return true;
+    
+    if (leftNaN != rightNaN) {
+      return leftNaN < rightNaN;
+    } else {
+      return left < right;
     }
-} ;
-	
-template <int RTYPE> struct comparator_type {
-	typedef std::less< typename storage_type<RTYPE>::type > type ;	
-} ;
-template <> struct comparator_type<STRSXP>{
-	typedef StringCompare type ;
-} ;
-   
+
+  }
+  
+};
+
+template <>
+struct comparator_type<SEXP> {
+  inline bool operator()(SEXP left, SEXP right) const {
+    return StrCmp(left, right) < 0;
+  }
+};   
 
 }
 }     

inst/include/Rcpp/traits/comparator_type.h

@@ -245,9 +245,10 @@ class Vector :
     Vector& sort(){
         typename traits::storage_type<RTYPE>::type* start = internal::r_vector_start<RTYPE>( Storage::get__() ) ;
         std::sort( 
-            start, start + size(), 
-            typename traits::comparator_type<RTYPE>::type()
-            ) ;
+            start, 
+            start + size(), 
+            typename traits::comparator_type<typename traits::storage_type<RTYPE>::type >()
+        ) ;
         return *this ;
     }
 

inst/include/Rcpp/vector/Vector.h

@@ -737,3 +737,23 @@ CharacterVector CharacterVector_test_const_proxy(const CharacterVector x){
     }
     return out ;
 }
+
+// [[Rcpp::export]]
+NumericVector sort_numeric(NumericVector x) {
+  return x.sort();
+}
+
+// [[Rcpp::export]]
+IntegerVector sort_integer(IntegerVector x) {
+  return x.sort();
+}
+
+// [[Rcpp::export]]
+CharacterVector sort_character(CharacterVector x) {
+  return x.sort();
+}
+
+// [[Rcpp::export]]
+LogicalVector sort_logical(LogicalVector x) {
+  return x.sort();
+}

inst/unitTests/cpp/Vector.cpp

@@ -658,5 +658,16 @@ if (.runThisTest) {
         res <- CharacterVector_test_const_proxy( letters )
         checkEquals( res, letters )
     }
+  
+    test.sort <- function() {
+        num <- setNames( c(1, -1, 4, NA, 5, NaN), letters[1:5] )
+        checkIdentical( sort_numeric(num), sort(num, na.last=TRUE) )
+        int <- as.integer(num)
+        checkIdentical( sort_integer(int), sort(int, na.last=TRUE) )
+        char <- setNames( sample(letters, 5), LETTERS[1:5] )
+        checkIdentical( sort_character(char), sort(char, na.last=TRUE) )
+        lgcl <- as.logical(int)
+        checkIdentical( sort_logical(lgcl), sort(lgcl, na.last=TRUE) )
+    }
 }