Introduction to Calling Fortran Subroutines from R

As a technical blogger, I’ve encountered numerous questions regarding the interaction between programming languages. One such fascinating scenario involves calling a Fortran subroutine from R, leveraging module functions within that subroutine. In this article, we will delve into the intricacies of achieving this goal and explore the necessary steps to execute it successfully.

Prerequisites

To call a Fortran subroutine from R, you’ll need:

• Familiarity with R programming language
• Knowledge of Fortran programming language (at least the basics)
• A Fortran compiler installed on your system (more details below)
• The Rcpp package for interfacing C/C++/Fortran code with R

Installing Fortran Compiler and Rcpp

Before we proceed, ensure you have a Fortran compiler installed. Popular options include:

• gfortran (GNU Fortran Compiler): usually included in Linux distributions
• Intel Fortran Compiler: widely used for high-performance computing
• IBM XL Fortran Compiler: commonly employed in academic and research environments

To install Rcpp, use the following command:

install.packages("Rcpp")

Creating a Shared Library (DLL) from Your Fortran Code

Next, compile your Fortran code into a shared library. This will involve several steps:

Step 1: Compile and Link the Fortran Code

Use your preferred Fortran compiler to create a shared library (.so or .dll file). The exact commands may vary depending on your system architecture and compiler version.

For example, with gfortran:

gfortran -shared -o mylib.so -c forme.f90 -c invdeux.f90

Step 2: Create the Interface File

Create an interface file in C++ that will act as a bridge between R and your Fortran code. This file should contain the necessary function declarations to interact with your shared library.

// mylib.cpp
#include "Rcpp.h"
#include "mylib.h"

// [[Rcpp::export]]
double autoc(double x, int k) {
  return x + k;
}

[[Rcpp::export]]
void invdeux(int n, double* answer) {
  // Using the autoc function here
  *answer = autoc(1.0 / n, n);
}

Step 3: Create a Makefile

Create a Makefile that will compile your C++ code and link it with your shared library.

# mylib.mk
CC=g++
CFLAGS=-Wall -std=c++11
LDFLAGS=-shared
LIBS=-lc

mylib: mylib.o libmylib.so
	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(LIBS)

mylib.o: mylib.cpp
	$(CC) $(CFLAGS) -c -o $@ $<

clean:
	rm -f *.o mylib*

Step 4: Compile and Run the Makefile

Run the Makefile to compile your C++ code and create a shared library.

make

Writing R Code to Call the Fortran Subroutine

Now that you have your shared library compiled, it’s time to write some R code to call your Fortran subroutine. Here’s an example:

# mylib.R
library(Rcpp)

# Load the shared library
mylib <- .register(
  package = "your_package",
  type = c("sharedLib", "dynamic")
)

# Define a function to call the invdeux subroutine
invdeux_n <- function(n) {
  # Call the invdeux subroutine and return the result
  answer <- numeric(1)
  mylib$invdeux(n, &answer)
  return(answer)
}

Note that in this example, we’re using the register() function from Rcpp to create a shared library that can be loaded into R. The mylib object is then used to call the invdeux() subroutine.

Conclusion

Calling a Fortran subroutine from R involves several steps: compiling your code into a shared library, creating an interface file in C++, and writing R code to interact with the shared library. While this may seem daunting at first, it’s actually quite straightforward once you understand the underlying concepts. With Rcpp providing a convenient API for interfacing C/C++/Fortran code with R, it’s easier than ever to explore new programming languages and integrate them into your existing workflow.

Additional Considerations

When working with shared libraries, keep in mind:

• Linking: When compiling the shared library, ensure that all necessary dependencies are linked correctly.
• Dependency Management: Manage dependencies carefully to avoid conflicts between different versions of libraries.
• Error Handling: Implement robust error handling mechanisms when interacting with external code.

With careful attention to these considerations, you’ll be able to successfully integrate your Fortran code into your R workflow and unlock new possibilities for collaboration and innovation.

Last modified on 2023-08-19