Integration of Fortran, C ++ with R

I would suggest that projects like this wrap your code into a package. I created a simple example of such a package, which I named mixedlang

which is available in this GitHub repo . I will describe the process of creating a package here.

I did the following steps:

1. Set up the package structure from R with RcppArmadillo::RcppArmadillo.package.skeleton("mixedlang")
   
   (I used RcppArmadillo, not Rcpp as the OP was - nothing special about this Armadillo example)
2. Added the C ++ and Fortran files described below to the folder src/
   
   
3. In R run Rcpp::compileAttributes("mixedlang/")
   
   thendevtools::install("mixedlang/")
   
   

Code

I created a simple C ++ function whose sole purpose (essentially) was to call a Fortran function. The example function takes a numeric vector, multiplies each element by its index, and returns the result. Let's look at the Fortran code first:

fortranfunction.f90

This function simply takes two doubles and multiplies them, returning the result:

REAL*8 FUNCTION MULTIPLY (X, Y) 
REAL*8 X, Y
MULTIPLY = X * Y
RETURN
END

      

        
        
        
      

    

test_function.cpp

Now we need to call this Fortran code from our C ++ code. In doing so, we need to consider a few things:

1. Fortran arguments are passed by reference, not by value.

2. Since it is MULTIPLY
   
   defined in another file, we need to declare it in our C ++ file so that the compiler knows the arguments and return types.

   and. When declaring a Fortran function for our C ++ file, we will discard the case of the function name and add an underscore as the Fortran compiler should do this by default.

   b. We must declare this function within extern "C"
   
   the communication specification extern "C"
   
   ; C ++ compilers generally cannot use function names as unique identifiers as they allow overloading, but in order to call Fortran functions we need to do exactly what the communication specification does extern "C"
   
   (see, for example, this SO answer ).

#include "RcppArmadillo.h"

// [[Rcpp::depends(RcppArmadillo)]]

// First we'll declare the MULTIPLY Fortran function
// as multiply_ in an extern "C" linkage specification
// making sure to have the arguments passed as pointers.
extern "C" {
    double multiply_(double *x, double *y);
}

// Now our C++ function
// [[Rcpp::export]]
Rcpp::NumericVector test_function(Rcpp::NumericVector x) {
    // Get the size of the vector
    int n = x.size();
    // Create a new vector for our result
    Rcpp::NumericVector result(n);
    for ( int i = 0; i < n; ++i ) {
        // And for each element of the vector,
        // store as doubles the element and the index
        double starting_value = x[i], multiplier = (double)i;
        // Now we can call the Fortran function,
        // being sure to pass the address of the variables
        result[i] = multiply_(&starting_value, &multiplier);
    }
    return result;
}

      

        
        
        
      

    

Output example

After installing the package, I ran the example

mixedlang::test_function(0:9)
# [1]  0  1  4  9 16 25 36 49 64 81

      

        
        
        
      

    

Likely sources of original poster problems

1. When trying to compile, initially they didn't let the compiler know where RcppArmadillo.h
   
   .
2. Trying to do it with sourceCpp
   
   just sourceCpp
   
   trouble; it wasn't actually done to handle multiple files (see, for example, this answer from Dirk Eddelbuettel ), which is necessary when dealing with multiple languages.

I'm not sure what happened when they tried to flip it into a package, so I put together this example.