C Basics

We will review the following topics from C Tutorial:

• Program Structure
• Basic Syntax
• Data types (Integer and Floating Point Types)
• Variables
• Operators (Arithmetic, Relational, Logical and Assignment)
• Loops
• Arrays
• Pointers
• Type Casting

We will not review these as they work very much like in R:

• Decision Making

The remaining sections are mostly beyond the scope of what we will discuss here.

Using .C()

The basic recipe for using .C is as follows:

• Write a function in .C that returns void and stores the desired result in one or more arguments expressly created for this purpose. Your function should have a C_ prefix.

• Compile your function into a shared library accessible to R using this command: R CMD SHLIB my_func.c with my_func.c replaced by your c program.

• Within an active R session, link to the shared library using dyn.load("my_func.so").

• Write an R wrapper to call your C function using .C with the following syntax: .C("C_my_func", arg1, arg2). The reason to use an R wrapper is to ensure that the arguments passed are of the correct size and type in order to avoid potentially fatal errors.

The middle two steps can be avoided by including these functions into an R package. We will discuss this briefly when turning to C++ and Rcpp.

A conceptual key to understanding how .C works is realizing that function arguments are passed as pointers to objects in memory rather than by value.

We will look at some examples of C coding available here.

Using .Call()

We can use .Call() to create and modify R level objects directly using functions in C. R level objects are of type SEXP for “S-expression”. These types are defined in the header file Rinternals.h which should be included in all C functions to be called with .Call().

When we create R level objects, we must protect them from garbage collection using PROTECT or a similar function. We later UNPROTECT them to allow the memory to be reallocated.

Recall that scalars in R are length one vectors. Consequently, the must be coerced to C type scalars to be uses as such. This can be done using the C functions as*: asLogical, asInteger, asReal, CHAR(asChar()).

경축! 아무것도 안하여 에스천사게임즈가 새로운 모습으로 재오픈 하였습니다.
어린이용이며, 설치가 필요없는 브라우저 게임입니다.
https://s1004games.com

Here is a simple example using the inline::cfunction.

library(inline)

## 
## Attaching package: 'inline'

## The following object is masked from 'package:Rcpp':
## 
##     registerPlugin

seqn = cfunction(signature(n_="integer", start_="integer"), 
 body="
 int i, n = asInteger(n_), start=asInteger(start_);
 SEXP out = PROTECT(allocVector(INTSXP, n));
 for(i=0; i<n; ++i){
   INTEGER(out)[i]=i+start;
 }
 UNPROTECT(1);
 return out;
")
seqn(8, 3)

## [1]  3  4  5  6  7  8  9 10

fib = cfunction(c(n_="integer"), body=
  "
  /* Declaratations */
  int n = asInteger(n_);
  SEXP out = PROTECT(allocVector(INTSXP, n));

  /* Function Body */
  INTEGER(out)[0] = 1;
  if(n > 1)  INTEGER(out)[1]=1;
  if(n > 2)
    {
      for(int i=2; i<n; i++)
        {
        INTEGER(out)[i] = INTEGER(out)[i-2] + INTEGER(out)[i-1];
        }
    }

  /* Clean up and return */
  UNPROTECT(1);
  return out;
  ")
fib(10)

##  [1]  1  1  2  3  5  8 13 21 34 55

Modifying inputs

Be careful about modifying input arguments without duplicating first as other R objects may point to the same location in memory owing to “copy-on-modify” semantics.
Here is a quick example from p. 441 of Advanced R using the “inline” package.

add_three = cfunction(c(x="numeric"),
  "
   REAL(x)[0] = REAL(x)[0] + 3;
   return x; 
  ")
y <- x <- 1
add_three(x)

## [1] 4

x

## [1] 4

y

## [1] 4

Here is a corrected version in which the argument is duplicated rather than modified in place.

add_3 = cfunction(c(x_="numeric"),
  "
   SEXP x = PROTECT(duplicate(x_));
   REAL(x)[0] = REAL(x)[0] + 3;
   UNPROTECT(1);
   return x; 
  ")
y <- x <- 1
add_3(x)

## [1] 4

x

## [1] 1

y

## [1] 1

Example

Here is another simple example.

Building a package with Rcpp

The sourceCpp function is convenient for interactive use and initial development. However, for larger projects with multiple functions it is better to maintain the code base using an R package. Rcpp automates much of the work involved in doing this via the compileAttributes function.

This function creates a C++ wrapper to any C++ functions tagged with the // [[Rcpp::export]] attribute that handles type conversion and an R wrapper that calls this function in turn. This makes for a relatively seamless process in which you only occasionally need to look into the translation details.

In the download above is avery simple R package Pkg with the getRegion function from the previous example.