passing in R array to C function with "NA"

I work in R using C libraries. I need to pass to a C function an array with numbers between 1 and 10 but that could also be "NA". Then in C, depending on the value I need to set the output. Here's a simplified code

heredyn.load("ranking.so")

fun <- function(ranking) {
  nrak <- length(ranking)
  out <- .C("ranking", as.integer(nrak), as.character(ranking), rr = as.integer(vector("integer",nrak)))
  out$rr
}

ranking <- sample(c(NA,seq(1,10)),10,replace=TRUE)
rr <- fun(ranking)

The C function could simply be such as

#include <R.h>

void ranking(int *nrak, char *ranking, int *rr) {
  int i ;

  for (i=0;i<*nrak;i++) {
    if (ranking[i] == 'NA')
      rr[i] = 1 ;
    else
      rr[i] = (int) strtol(&ranking[i],(char **)NULL,10) ;
  }
}

Due to the "NA" value I set ranking as character but maybe there's another way to do that, using integer and without replacing "NA" to 0 before calling the function?

(The code like this, gives me always an array of zeros...)

Solution

Test for whether the value is an NA using R_NaInt, like

#include <R.h>

void ranking_c(int *nrak, int *ranking, int *rr) {
  for (int i=0; i < *nrak; i++)
      rr[i] = R_NaInt == ranking[i] ? -1 : ranking[i];
}

Invoke from R by explicitly allowing NAs

> x = c(1:2, NA_integer_)
> .C("ranking_c", length(x), as.integer(x), integer(length(x)), NAOK=TRUE)[[3]]
[1]  1  2 -1

Alternatively, use R's .Call() interface. Each R object is represented as an S-expression. There are C-level functions to manipulate S-expressions, e.g., length Rf_length(), data access INTEGER(), and allocation Rf_allocVector() of different types of S-expressions such as INTSXP for integer vectors.

R memory management uses a garbage collector that can run on any call that allocates memory. It is therefore best practice to PROTECT() any R allocation while in scope.

Your function will accept 0 or more S-expressions as input, and return a single S-expression; it might be implemented as

#include <Rinternals.h>
#include <R_ext/Arith.h>

SEXP ranking_call(SEXP ranking)
{
    /* allocate space for result, PROTECTing from garbage collection */
    SEXP result = PROTECT(Rf_allocVector(INTSXP, Rf_length(ranking)));

    /* assign result */
    for (int i = 0; i < Rf_length(ranking); ++i)
        INTEGER(result)[i] =
            R_NaInt == INTEGER(ranking)[i] ? -1 : INTEGER(ranking)[i];

    UNPROTECT(1);               /* no more need to protect */
    return result;
}

And invoked from R with .Call("ranking_call", as.integer(ranking)).

Using .Call is more efficient than .C in terms of speed and memory allocation (.C may copy atomic vectors on the way in), but the primary reason to use it is for the flexibility it offers in terms of working directly with R's data structures. This is especially important when the return values are more complicated than atomic vectors.