Skip to content

Instantly share code, notes, and snippets.

@romainfrancois
Last active December 23, 2015 21:59
Show Gist options
  • Save romainfrancois/6700521 to your computer and use it in GitHub Desktop.
Save romainfrancois/6700521 to your computer and use it in GitHub Desktop.
A new approach of NA handling

I've implemented a new approch of NA handling in Rcpp11 (it is straightforward to port this to Rcpp).

To test for missing values in Rcpp there are several ways:

  • rely on R api macros (NA_REAL, ...)
  • use Vector<RTYPE>::is_na(.)
  • use traits::is_na(.)

These lack expressiveness and what I've implemented in Rcpp11 allows this syntax:

double x ; int y; String s ; // ... values coming from somewhere 

// we can just us the equality operator to test for equality against NA: 

double b1 = x == NA ;
double b2 = NA == x ;

double b1 = y == NA ;
double b2 = NA == y ;

double b1 = s == NA ;
double b2 = NA == s ;
// Copyright (C) 2013 Romain Francois
//
// This file is part of Rcpp11.
//
// Rcpp11 is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// Rcpp11 is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rcpp11. If not, see <http://www.gnu.org/licenses/>.
#ifndef Rcpp_Na_Proxy_h
#define Rcpp_Na_Proxy_h
namespace Rcpp{
class Na_Proxy{} ;
static Na_Proxy NA ;
}
inline bool operator==(double x , Rcpp::Na_Proxy){ return Rcpp::traits::is_na<REALSXP>(x) ; }
inline bool operator==(int x , Rcpp::Na_Proxy){ return Rcpp::traits::is_na<INTSXP>(x) ; }
inline bool operator==(Rcpp::String x, Rcpp::Na_Proxy){ return Rcpp::traits::is_na<STRSXP>(x.get_sexp()) ; }
inline bool operator==(Rcomplex x , Rcpp::Na_Proxy){ return Rcpp::traits::is_na<CPLXSXP>(x) ; }
inline bool operator==(SEXP x , Rcpp::Na_Proxy){ return TYPEOF(x)==CHARSXP && Rcpp::traits::is_na<STRSXP>(x) ; }
inline bool operator==(std::string x , Rcpp::Na_Proxy){ return false ; }
inline bool operator==(const char* x , Rcpp::Na_Proxy){ return false ; }
inline bool operator==(Rcpp::internal::string_proxy<STRSXP> x, Rcpp::Na_Proxy){ return Rcpp::traits::is_na<STRSXP>(x.get()) ; }
inline bool operator==(Rcpp::Na_Proxy, double x ){ return Rcpp::traits::is_na<REALSXP>(x) ; }
inline bool operator==(Rcpp::Na_Proxy, int x ){ return Rcpp::traits::is_na<INTSXP>(x) ; }
inline bool operator==(Rcpp::Na_Proxy, Rcpp::String x ){ return Rcpp::traits::is_na<STRSXP>(x.get_sexp()) ; }
inline bool operator==(Rcpp::Na_Proxy, SEXP x ){ return TYPEOF(x)==CHARSXP && Rcpp::traits::is_na<STRSXP>(x) ; }
inline bool operator==(Rcpp::Na_Proxy, Rcomplex x ){ return Rcpp::traits::is_na<CPLXSXP>(x) ; }
inline bool operator==(Rcpp::Na_Proxy, std::string x ){ return false ; }
inline bool operator==(Rcpp::Na_Proxy, const char* x ){ return false ; }
inline bool operator==(Rcpp::Na_Proxy, Rcpp::internal::string_proxy<STRSXP> x){ return Rcpp::traits::is_na<STRSXP>(x.get()) ; }
#endif
#include <Rcpp.h>
using namespace Rcpp ;
// [[Rcpp::export]]
LogicalVector na_proxy(){
CharacterVector s = { "foo" } ;
return LogicalVector::create(
NA_REAL == NA,
NA_INTEGER == NA,
NA_STRING == NA,
true == NA,
false == NA,
1.2 == NA,
12 == NA,
"foo" == NA,
s[0] == NA,
NA == NA_REAL,
NA == NA_INTEGER,
NA == NA_STRING,
NA == true,
NA == false,
NA == 1.2 ,
NA == 12 ,
NA == "foo",
NA == s[0]
) ;
}
/*** R
stopifnot( identical( na_proxy(), rep(c(TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE) , 2) ) )
*/
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment