{"id":199704,"date":"2023-12-12T09:12:34","date_gmt":"2023-12-12T14:12:34","guid":{"rendered":"https:\/\/ibkrcampus.com\/?p=199704"},"modified":"2023-12-15T15:40:07","modified_gmt":"2023-12-15T20:40:07","slug":"wrapping-c-code-in-an-r-package","status":"publish","type":"post","link":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/","title":{"rendered":"Wrapping C Code in an R Package"},"content":{"rendered":"\n

The article “Wrapping C Code in an R Package” first appeared on Jonathan Carroll’s blog<\/a>. <\/em><\/p>\n\n\n\n

Your collaborator says to you \u201cI have some code I\u2019d like to distribute to people who will probably work in R most of the time. I don\u2019t write R, but I write C. Can you package this up for me?\u201d so you have a few options: re-write the code in R, package up the C code and make it available<\/em> in R, or say no. I decided to try out the second of these, and this post details how I achieved that.<\/p>\n\n\n\n

Before we even start, this<\/a> (blog.davisvaughan.com) is an excellent post summarising many of the finer points involved here – go read that! Then, read some of @coolbutuseless\u2019<\/a> (github.com) various<\/a> (github.com) repositories demonstrating<\/a> (github.com) how to wrap C code into R packages. These, and many others, go much deeper into how to achieve this, but I\u2019m going to detail what I did because a) I\u2019ll want to remember, later; b) I had enough trouble piecing together what I needed between these excellent posts and some older, possibly out of date posts; and c) I did<\/em> build some functionality beyond what was done in those straightforward examples.<\/p>\n\n\n\n

Those of you who know R really well probably know that the language itself is in no small part written in C<\/a> (github.com). Many packages do the same, usually for performance reasons. This becomes most apparent if you install a package \u201cfrom source\u201d and see a lot of this mess fly past in your console<\/p>\n\n\n\n

gcc -I\"\/usr\/share\/R\/include\" -DNDEBUG -I.\/pkg\/ -fvisibility=hidden -fpic -g -O2 -ffile-prefix-map=\/build\/r-base-4A2Reg\/r-base-4.1.2=. -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -g -c file1.c -o file1.o
gcc -I\"\/usr\/share\/R\/include\" -DNDEBUG -I.\/pkg\/ -fvisibility=hidden -fpic -g -O2 -ffile-prefix-map=\/build\/r-base-4A2Reg\/r-base-4.1.2=. -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -g -c file2.c -o file2.o
gcc -I\"\/usr\/share\/R\/include\" -DNDEBUG -I.\/pkg\/ -fvisibility=hidden -fpic -g -O2 -ffile-prefix-map=\/build\/r-base-4A2Reg\/r-base-4.1.2=. -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -g -c pkg.c -o pkg.o
gcc -shared -L\/usr\/lib\/R\/lib -Wl,-Bsymbolic-functions -flto=auto -ffat-lto-objects -flto=auto -Wl,-z,relro -o pkg.so file1.o file2.o pkg.o -L\/usr\/lib\/R\/lib -lR<\/code><\/pre>\n\n\n\n
Other languages are supported, including Fortran (yet to be superseded for numerical libraries), C++, Rust, and various others. You can usually dig into the source of these if you can track down where they come from. When debugging a function call, R is happy to step through individual lines of R code. Try the following<\/p>\n\n\n\n
debugonce(seq.default)\nseq(5)<\/code><\/pre>\n\n\n\n
and step through the lines of seq.default<\/code> until it reaches 1L:from<\/code> (yes, seq(from = x)<\/code> produces the values 1<\/code> to from<\/code>\u2026 sigh) where it returns that value as<\/p>\n\n\n\n
exiting from: seq.default(5)\n[1] 1 2 3 4 5<\/code><\/pre>\n\n\n\n
When the function involves C code, though, R can\u2019t step through that because it\u2019s compiled. One of the most common ways to hit that limitation is when a function calls either .Internal()<\/code> or .Primitive()<\/code>.<\/p>\n\n\n\n
I went looking for a function containing one of these (there are plenty) and found .row_names_info<\/code><\/p>\n\n\n\n
# number of rownames\n.row_names_info(mtcars)<\/code><\/pre>\n\n\n\n
## [1] 32<\/code><\/pre>\n\n\n\n
# the rownames themselves\n.row_names_info(mtcars, type = 0)<\/code><\/pre>\n\n\n\n
##  [1] \"Mazda RX4\"           \"Mazda RX4 Wag\"       \"Datsun 710\"         \n##  [4] \"Hornet 4 Drive\"      \"Hornet Sportabout\"   \"Valiant\"            \n##  [7] \"Duster 360\"          \"Merc 240D\"           \"Merc 230\"           \n## [10] \"Merc 280\"            \"Merc 280C\"           \"Merc 450SE\"         \n## [13] \"Merc 450SL\"          \"Merc 450SLC\"         \"Cadillac Fleetwood\" \n## [16] \"Lincoln Continental\" \"Chrysler Imperial\"   \"Fiat 128\"           \n## [19] \"Honda Civic\"         \"Toyota Corolla\"      \"Toyota Corona\"      \n## [22] \"Dodge Challenger\"    \"AMC Javelin\"         \"Camaro Z28\"         \n## [25] \"Pontiac Firebird\"    \"Fiat X1-9\"           \"Porsche 914-2\"      \n## [28] \"Lotus Europa\"        \"Ford Pantera L\"      \"Ferrari Dino\"       \n## [31] \"Maserati Bora\"       \"Volvo 142E\"<\/code><\/pre>\n\n\n\n
if we wanted to see what .row_names_info()<\/code> does we would write<\/p>\n\n\n\n
.row_names_info<\/code><\/pre>\n\n\n\n
## function (x, type = 1L) \n## .Internal(shortRowNames(x, type))\n## <bytecode: 0x563e6bf3c890>\n## <environment: namespace:base><\/code><\/pre>\n\n\n\n
but we can\u2019t see any deeper unless we ask where that C code lives. I recommend using pryr::show_c_source()<\/code> (as I did in a previous post<\/a>) to identify the C code for these, e.g. <\/p>\n\n\n\n
pryr::show_c_source(.Internal(shortRowNames(mtcars)))<\/code><\/pre>\n\n\n\n
shortRowNames is implemented by do_shortRowNames with op = 0\n<\/code><\/pre>\n\n\n\n
which opens a GitHub search of a copy of the R source<\/a> (github.com) in a browser. The file we want is attrib.c<\/code><\/a> (github.com) and contains the C code<\/p>\n\n\n\n
SEXP do_shortRowNames(SEXP call, SEXP op, SEXP args, SEXP env)\n{\n    \/* return  n if the data frame 'vec' has c(NA, n) rownames;\n     *\t       nrow(.) otherwise;  note that data frames with nrow(.) == 0\n     *\t\thave no row.names.\n     ==> is also used in dim.data.frame() *\/\n    checkArity(op, args);\n    SEXP s = getAttrib0(CAR(args), R_RowNamesSymbol), ans = s;\n    int type = asInteger(CADR(args));\n    if( type  2)\n\terror(_(\"invalid '%s' argument\"), \"type\");\n    if(type >= 1) {\n\tint n = (isInteger(s) && LENGTH(s) == 2 && INTEGER(s)[0] == NA_INTEGER)\n\t    ? INTEGER(s)[1] : (isNull(s) ? 0 : LENGTH(s));\n\tans = ScalarInteger((type == 1) ? n : abs(n));\n    }\n    return ans;\n}<\/code><\/pre>\n\n\n\n
Fully interpreting this is beyond the scope of this post, but the links at the start of this post cover most of what\u2019s not plain C code here.<\/p>\n\n\n\n
I won\u2019t share my collaborator\u2019s exact code, but I can write enough C that I can create something with all the relevant features.<\/p>\n\n\n\n
Let\u2019s calculate Pythagorean Triples<\/a> (en.wikipedia.org)! These are sets of 3 integers (whole numbers) a<\/code>, b<\/code>, and c<\/code> such that a triangle with sides of those lengths will be a right-triangle (contains a 90 degree \/ right-angle). These have the property that<\/p>\n\n\n\n
a<\/em>2<\/sup> + b<\/em>2<\/sup> = c<\/em>2<\/sup><\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Pythagorean theorem <\/em>https:\/\/en.wikipedia.org\/wiki\/Pythagorean_theorem<\/a> (en.wikipedia.org)<\/em><\/p>\n\n\n\n
The smallest of these is 3, 4, 5<\/code> because<\/p>\n\n\n\n
32<\/sup> + 42<\/sup> = 9 + 16 = 25 = 52<\/sup><\/p>\n\n\n\n
Generating these just happens to fit the use-case I\u2019m emulating, plus I have a whole other blog post coming up about these (stay tuned!).<\/p>\n\n\n\n
Some C code to generate these up to some maximum side-length, written similar to the code I received, is<\/p>\n\n\n\n
#include \n#include \n#include \nint main (int argc, char *argv[]) {\n  int a, b, c;\n  int maxval;\n  int ***triangles;\n  if ( argc != 2 ) {\n    printf(\"Usage: triangle max_side_length\\n\");\n    exit(EXIT_FAILURE);\n  }\n  maxval = atoi( argv[1] );\n  triangles = (int ***) malloc (maxval * sizeof(int **));\n  for (a = 0; a < maxval; ++a) {\n    triangles[a] = (int **) malloc (maxval * sizeof(int *));\n    for (b = 0; b < maxval; ++b) {\n      triangles[a][b] = (int *) malloc (maxval * sizeof(int));\n      for (c = 0; c < maxval; ++c) {\n        triangles[a][b][c] = 0;\n      }\n    }\n  }\n  for (c = 1; c <= maxval; c++) {\n    for (b = 1; b <= c; b++)\n      for (a = 1; a <= b; a++)\n        if ( ( pow ( a, 2 ) + pow ( b, 2 ) ) == pow ( c, 2 ) ) {\n          triangles[a][b][c] = a + b + c;\n        }\n  }\n  printf("%4s\\t%4s\\t%4s\\t%4s\\n", "a", "b", "c", "sum");\n  printf("   -------------------------\\n");\n  for (c = 1; c <= maxval; c++) {\n    for (b = 1; b <= c; b++)\n      for (a = 1; a <= b; a++)\n        if ( ( pow ( a, 2 ) + pow ( b, 2 ) ) == pow ( c, 2 ) ) {\n          printf("%4i\\t%4i\\t%4i\\t%4i\\n", a, b, c, triangles[a][b][c]);\n          }\n      }\n  exit(EXIT_SUCCESS);\n}<\/code><\/pre>\n\n\n\n
I won\u2019t make this an entire C tutorial, but the main pieces are:<\/p>\n\n\n\n
Load some libraries for printing to screen, doing math, \u2026<\/p>\n\n\n\n
#include <stdio.h>\n#include <stdlib.h>\n#include <math.h><\/code><\/pre>\n\n\n\n
Define an entrypoint function (the thing that will run when the code is run) which takes some number of character arguments argv<\/code>, the first of which is the compiled name of the program itself<\/p>\n\n\n\n
int main (int argc, char *argv[]) {<\/code><\/pre>\n\n\n\n
Define some variables, the most significant being triangles<\/code> which is denoted as a pointer to a pointer to a pointer (!)<\/p>\n\n\n\n
  int a, b, c;\n  int maxval;\n  int ***triangles;<\/code><\/pre>\n\n\n\n
That\u2019s a lot of redirection, but it\u2019s just creating a reference to a 3-dimensional array.<\/p>\n\n\n\n
Side-note: 0-indexed languages actually make a bit more sense when working with pointer math because a \u201cvector\u201d of memory addresses really only needs to \u201cpoint\u201d to the starting address, then every element is some offset away from that, so the first element of some vector vec<\/code> might have some address x<\/code>, but you can access that with vec[0]<\/code>. You can access the next element with vec[1]<\/code> which means \u201coffset 1 position from x<\/code>, the starting address.\u201d You can access the fifth value by offsetting 4 positions, so vec[4]<\/code>.<\/p>\n\n\n\n
One of my favourite bits of C trivia is that this syntactic sugar of using square brackets to identify positions actually translates to<\/p>\n\n\n\n
vec[0] is at address x + 0 => vec + 0\nvec[1] is at address x + 1 => vec + 1\nvec[2] is at address x + 2 => vec + 2\n...\nvec[5] is at address x + 5 => vec + 5<\/code><\/pre>\n\n\n\n
but addition (+<\/code>) is symmetric (commutative) so we can just as easily write<\/p>\n\n\n\n
vec + 0 => 0 + vec => 0 + x is at address 0[vec]\nvec + 1 => 1 + vec => 1 + x is at address 1[vec]\nvec + 2 => 2 + vec => 2 + x is at address 2[vec]\n...\nvec + 5 => 5 + vec => 5 + x is at address 5[vec]<\/code><\/pre>\n\n\n\n
and it all works out\u2026 5[obj]<\/code> is valid, and corresponds to the same address as obj[5]<\/code>.<\/p>\n\n\n\n
Back to our function. If only one argument is passed in (the name of the program) then the usage information is printed, otherwise the next argument is used to set the upper bound on the length of a side of the triangle, converting it from a string to an int with atoi<\/code><\/p>\n\n\n\n
 if ( argc != 2 ) {\n    printf(\"Usage: triangle max_side_length\\n\");\n    exit(EXIT_FAILURE);\n  }\n\n  maxval = atoi( argv[1] );<\/code><\/pre>\n\n\n\n
Next, the array is allocated (and assigned a default value of 0)<\/p>\n\n\n\n
  triangles = (int ***) malloc (maxval * sizeof(int **));\n  for (a = 0; a < maxval; ++a) {\n    triangles[a] = (int **) malloc (maxval * sizeof(int *));\n    for (b = 0; b < maxval; ++b) {\n      triangles[a][b] = (int *) malloc (maxval * sizeof(int));\n      for (c = 0; c < maxval; ++c) {\n        triangles[a][b][c] = 0;\n      }\n    }\n  }<\/code><\/pre>\n\n\n\n
and then, finally, we do the \u2018calculation\u2019 which just involves stepping through every value, and if our criteria of<\/p>\n\n\n\n
a<\/em>2<\/sup> + b<\/em>2<\/sup> == c<\/em>2<\/sup><\/p>\n\n\n\n
is met, we assign the sum of these to an element in triangles<\/code> indexed by a<\/code>, b<\/code>, and c<\/code><\/p>\n\n\n\n
  for (c = 1; c <= maxval; c++) {\n    for (b = 1; b <= c; b++)\n      for (a = 1; a <= b; a++)\n        if ( ( pow ( a, 2 ) + pow ( b, 2 ) ) == pow ( c, 2 ) ) {\n          triangles[a][b][c] = a + b + c;\n        }\n  }<\/code><\/pre>\n\n\n\n
This isn\u2019t efficient<\/em> at all – there will be lots of 0<\/code> values, but this is a simple program.<\/p>\n\n\n\n
The last section of the code just loops back through all of a<\/code>, b<\/code>, and c<\/code> and when it finds a non-zero element, it prints it, along with the sum a + b + c<\/code> (the value in triangles[a][b][c]<\/code>)<\/p>\n\n\n\n
  printf(\"%4s\\t%4s\\t%4s\\t%4s\\n\", \"a\", \"b\", \"c\", \"sum\");\n  printf(\"   -------------------------\\n\");\n  for (c = 1; c <= maxval; c++) {\n    for (b = 1; b <= c; b++)\n      for (a = 1; a <= b; a++)\n        if ( ( pow ( a, 2 ) + pow ( b, 2 ) ) == pow ( c, 2 ) ) {\n          printf("%4i\\t%4i\\t%4i\\t%4i\\n", a, b, c, triangles[a][b][c]);\n          }\n      }<\/code><\/pre>\n\n\n\n
With all of this saved as triangles.c<\/code><\/a> (github.com) we can compile and run this code in a terminal<\/p>\n\n\n\n
$ cc -O -o triangle triangles.c\n\n$ .\/triangle \nUsage: triangle max_side_length\n\n$ .\/triangle 16\n   a\t   b\t   c\t sum\n   -------------------------\n   3\t   4\t   5\t  12\n   6\t   8\t  10\t  24\n   5\t  12\t  13\t  30\n   9\t  12\t  15\t  36<\/code><\/pre>\n\n\n\n
Woot! You can even check that it has worked:<\/p>\n\n\n\n
92<\/sup> + 122<\/sup> = 81 + 144 = 225 = 152<\/sup><\/p>\n\n\n\n
Back to the goal of this post – how do we get R to run that? We have some C code, now what?<\/p>\n\n\n\n
First, I created an R package. I like using RStudio for this as it auto-generates a lot of the structure I want. It does, however, create an example R file R\/hello.R<\/code> (and corresponding man\/hello.Rd<\/code> page) so I delete those. I also delete the NAMESPACE<\/code> because I\u2019m going to use {roxygen} to generate a new one. I check \u2018Generate documentation with Roxygen\u2019 in the Build tools menu, making sure to select \u2018Build & Reload\u2019 (which should be a default, no?)<\/p>\n\n\n
\n
\"\"
Generate documentation with Roxygen<\/figcaption><\/figure>\n<\/div>\n\n\n
and build my empty package.<\/p>\n\n\n\n
I love<\/em> the {usethis} package for building packages, and there\u2019s support there for what we\u2019re doing, too! usethis::use_c()<\/code> sets up some structure and adds the required boilerplate so that Roxygen knows we\u2019re using C code. This does add a src\/code.c<\/code> file we can delete and in its place we can put our own C code.<\/p>\n\n\n\n
If you read the links at the start of this post, you\u2019ll recognise that this C code isn\u2019t quite ready to be used in an R package, though – we need to be able to send an R object (a SEXP<\/code>) to this C code, not a char<\/code>. More importantly, the functionality of the C code is all wrapped up in the main()<\/code> entrypoint function – it would be great if that was refactored out to another function that could be called from main()<\/code> but also from an R-facing function.<\/p>\n\n\n\n
I communicated this to my colleague and they agreed we could refactor that, but they want to still run the C code from the command line, so we can\u2019t just put everything<\/em> in our R-facing function. The actual processing in the code could go to a new function that doesn\u2019t return anything, but does update the 3-dimensional array passed by reference<\/p>\n\n\n\n
void calculate_sum(int maxval, int ****tri_sum) {\n  int a, b, c;\n  for (c = 1; c <= maxval; c++) {\n    for (b = 1; b <= c; b++)\n      for (a = 1; a <= b; a++)\n        if ( ( pow ( a, 2 ) + pow ( b, 2 ) ) == pow ( c, 2 ) ) {\n          (*tri_sum)[a][b][c] = a + b + c;\n        }\n  }\n}\n[... in main()]\n printf("calling external sum\\n");\n calculate_sum(maxval, &triangles);<\/code><\/pre>\n\n\n\n
Yes, that\u2019s a pointer to a pointer to a pointer to a pointer (!!!!).<\/p>\n\n\n\n
The gotchas I encountered here were that<\/p>\n\n\n\n
*tri_sum[a][b][c]<\/code><\/pre>\n\n\n\n
would be a pointer to the indexed<\/em> object, so I needed<\/p>\n\n\n\n
(*tri_sum)[a][b][c]<\/code><\/pre>\n\n\n\n
and &triangles<\/code> sends a reference to the triangles<\/code> object.<\/p>\n\n\n\n
Compiling and running this<\/a> (github.com) shows that we\u2019ve successfully refactored out the main functionality<\/p>\n\n\n\n
$ cc -O -o triangle1 triangles1.c\n\n$ .\/triangle1 20\ncalling external sum\n   a\t   b\t   c\t sum\n   -------------------------\n   3\t   4\t   5\t  12\n   6\t   8\t  10\t  24\n   5\t  12\t  13\t  30\n   9\t  12\t  15\t  36\n   8\t  15\t  17\t  40\n  12\t  16\t  20\t  48<\/code><\/pre>\n\n\n\n
But this still isn\u2019t quite<\/em> what we need for R\u2026 we need to pass and return SEXP<\/code>s.<\/p>\n\n\n\n
Rather than disrupt the runnable C code, we can add some additional R-specific code. That requires the R-related libraries<\/p>\n\n\n\n
#include <R.h>\n#include <Rinternals.h><\/code><\/pre>\n\n\n\n
(keeping in mind that these are required<\/em> if the user is compiling all of this code – it\u2019s possible, but perhaps we\u2019ll comment these out when just using the C code standalone).<\/p>\n\n\n\n
We need a function that takes a SEXP<\/code> (our maximum value) and returns a SEXP<\/code> – this is required, but so far we\u2019re just printing to screen. We\u2019ll return something<\/em> for now. A function that meets these criteria and calls the new calculate_sum()<\/code> could be<\/a> (github.com)<\/p>\n\n\n\n
SEXP C_triangles(SEXP maximum) {\n  int a, b, c;\n  int ***triangles;\n  int maxval = * INTEGER(maximum);\n  triangles = (int ***) malloc (maxval * sizeof(int **));\n  for (a = 0; a < maxval; ++a) {\n    triangles[a] = (int **) malloc (maxval * sizeof(int *));\n    for (b = 0; b < maxval; ++b) {\n      triangles[a][b] = (int *) malloc (maxval * sizeof(int));\n      for (c = 0; c < maxval; ++c) {\n        triangles[a][b][c] = 0;\n      }\n    }\n  }\n  printf("calling C function to calc sum\\n");\n  calculate_sum(maxval, &triangles);\n  printf("%4s\\t%4s\\t%4s\\t%4s\\n", "a", "b", "c", "sum");\n  printf("   -------------------------\\n");\n  for (c = 1; c < maxval; ++c) {\n    for (b = 1; b <= c; ++b)\n      for (a = 1; a <= b; ++a)\n        if ( ( pow ( a, 2 ) + pow ( b, 2 ) ) == pow ( c, 2 ) ) {\n          printf("%4i\\t%4i\\t%4i\\t%4i\\n", a, b, c, triangles[a][b][c]);\n        }\n  }\n  SEXP result = PROTECT(allocVector(LGLSXP, 1));\n  LOGICAL(result)[0] = 1;\n  UNPROTECT(1);\n  return(result);\n}<\/code><\/pre>\n\n\n\n
This is very similar to what\u2019s in main()<\/code> – it still performs the allocation then calls out to the calculating code, then prints the result. The only new part is creating a logical result<\/code> object (1<\/code> == TRUE<\/code>) so that there\u2019s something to return.<\/p>\n\n\n\n
You can read about PROTECT<\/code> which guards against garbage collection in the R-exts manual<\/a> (cran.r-project.org).<\/p>\n\n\n\n
The new functions called here such as allocVector<\/code> come from the Rinternals library and are macros for functions starting with Rf_<\/code> – i.e. Rf_allocVector<\/code>. I had some issues initially because I followed some guides which used #define R_NO_REMAP<\/code>. Keep in mind that if you use that (so that library functions aren\u2019t remapped) you will need to use the Rf_<\/code> versions of these functions. I ended up removing the #define<\/code> myself, but I\u2019m not sure if that will bite me later.<\/p>\n\n\n\n
This also needs to convert the SEXP<\/code> input maximum<\/code> to a C int<\/code> via * INTEGER(maximum)<\/code>.<\/p>\n\n\n\n
We now have something that should<\/em> work in our R package! Saving this as src\/triangles.c<\/code> we can add the R interface as R\/triangles.R<\/code> containing just<\/p>\n\n\n\n
#' triangles\n#'\n#' @export\ntriangles <- function(maxval) {\n  .Call(\"C_triangles\", as.integer(maxval))\n}<\/code><\/pre>\n\n\n\n
where we definitely only send an integer to the C function.<\/p>\n\n\n\n
Build the package, which compiles the code, and load the package<\/p>\n\n\n\n
library(triangles)\ntriangles(20)<\/code><\/pre>\n\n\n\n
calling C function to calc sum\n   a\t   b\t   c\t sum\n   -------------------------\n   3\t   4\t   5\t  12\n   6\t   8\t  10\t  24\n   5\t  12\t  13\t  30\n   9\t  12\t  15\t  36\n   8\t  15\t  17\t  40\n[1] TRUE<\/code><\/pre>\n\n\n\n
We see the debug print statement, then the printed output, and finally our returned TRUE<\/code>. Success!<\/p>\n\n\n\n
The original code was made to work in a command line pipeline where the values were read back in by a subsequent program, e.g.<\/p>\n\n\n\n
$ .\/triangle 16 | tail +3 | awk '{ sum += $4 } END { print sum }'\n102<\/code><\/pre>\n\n\n\n
so printing to stdout<\/code> made sense there, but we want to use<\/em> the values in R, so it would be great to return an actual data.frame<\/code>. This repo<\/a> (github.com) contains a great example of doing that but I want to return a data.frame<\/code> with a variable number of rows, and I need to allocate data into that. ChatGPT actually got me close enough to a working version. Here\u2019s what I ended up with<\/p>\n\n\n\n
 [...]\n  calculate_sum(maxval, &triangles);\n  \/* count rows *\/\n  int nrows = 0;\n  for (c = 1; c < maxval; ++c) {\n    for (b = 1; b <= c; ++b)\n      for (a = 1; a <= b; ++a)\n          if (triangles[a][b][c] != 0) {\n          nrows += 1;\n        }\n  }\n  \/* output a data.frame *\/\n  int ncols = 4;\n  SEXP col1, col2, col3, col4, df;\n  PROTECT(df = allocVector(VECSXP, ncols));\n  PROTECT(col1 = allocVector(INTSXP, nrows));\n  PROTECT(col2 = allocVector(INTSXP, nrows));\n  PROTECT(col3 = allocVector(INTSXP, nrows));\n  PROTECT(col4 = allocVector(INTSXP, nrows));\n  int j = 0;\n  for (c = 1; c < maxval; ++c) {\n    for (b = 1; b <= c; ++b) {\n      for (a = 1; a <= b; ++a) {\n        if (triangles[a][b][c] != 0) {\n          INTEGER(col1)[j] = a;\n          INTEGER(col2)[j] = b;\n          INTEGER(col3)[j] = c;\n          INTEGER(col4)[j] = triangles[a][b][c];\n          j += 1;\n        }\n      }\n    }\n  }\n  SET_VECTOR_ELT(df, 0, col1);\n  SET_VECTOR_ELT(df, 1, col2);\n  SET_VECTOR_ELT(df, 2, col3);\n  SET_VECTOR_ELT(df, 3, col4);\n  SEXP colNames;\n  PROTECT(colNames = allocVector(STRSXP, ncols));\n  SET_STRING_ELT(colNames, 0, mkChar("a"));\n  SET_STRING_ELT(colNames, 1, mkChar("b"));\n  SET_STRING_ELT(colNames, 2, mkChar("c"));\n  SET_STRING_ELT(colNames, 3, mkChar("sum"));\n  setAttrib(df, R_NamesSymbol, colNames);\n  SEXP rowNames;\n  PROTECT(rowNames = allocVector(STRSXP, nrows));\n  for (int i = 0; i < nrows; ++i) {\n    char rowName[11];\n    snprintf(rowName, sizeof(rowName), "%10d", i + 1\n    SET_STRING_ELT(rowNames, i, mkChar(rowName));\n  }\n  setAttrib(df, R_RowNamesSymbol, rowNames);\n  SEXP className;\n  PROTECT(className = allocVector(STRSXP, 1));\n  SET_STRING_ELT(className, 0, mkChar("data.frame"));\n  classgets(df, className);\n  UNPROTECT(8);\n  return df;<\/code><\/pre>\n\n\n\n
Going through the biggest parts of this: first we identify how many rows we want to output by counting the nonzero elements of the passed-by-reference triangles<\/code><\/p>\n\n\n\n
 \/* count rows *\/\n  int nrows = 0;\n  for (c = 1; c < maxval; ++c) {\n    for (b = 1; b <= c; ++b)\n      for (a = 1; a <= b; ++a)\n          if (triangles[a][b][c] != 0) {\n          nrows += 1;\n        }\n  }<\/code><\/pre>\n\n\n\n
then allocating vectors – first a list the length of the number of columns (4) then one for each of the columns with length nrows<\/code><\/p>\n\n\n\n
\/* output a data.frame *\/\n  int ncols = 4;\n\n  SEXP col1, col2, col3, col4, df;\n  PROTECT(df = allocVector(VECSXP, ncols));\n\n  PROTECT(col1 = allocVector(INTSXP, nrows));\n  PROTECT(col2 = allocVector(INTSXP, nrows));\n  PROTECT(col3 = allocVector(INTSXP, nrows));\n  PROTECT(col4 = allocVector(INTSXP, nrows));<\/code><\/pre>\n\n\n\n
These are then populated in a loop with a new counter for the nonzero elements<\/p>\n\n\n\n
 int j = 0;\n  for (c = 1; c < maxval; ++c) {\n    for (b = 1; b <= c; ++b) {\n      for (a = 1; a <= b; ++a) {\n        if (triangles[a][b][c] != 0) {\n          INTEGER(col1)[j] = a;\n          INTEGER(col2)[j] = b;\n          INTEGER(col3)[j] = c;\n          INTEGER(col4)[j] = triangles[a][b][c];\n          j += 1;\n        }\n      }\n    }\n  }<\/code><\/pre>\n\n\n\n
and finally the vectors linked into the list<\/p>\n\n\n\n
  SET_VECTOR_ELT(df, 0, col1);\n  SET_VECTOR_ELT(df, 1, col2);\n  SET_VECTOR_ELT(df, 2, col3);\n  SET_VECTOR_ELT(df, 3, col4);<\/code><\/pre>\n\n\n\n
The rest is mostly boilerplate of setting up the data.frame<\/code>: assigning column names<\/p>\n\n\n\n
  SEXP colNames;\n  PROTECT(colNames = allocVector(STRSXP, ncols));\n  SET_STRING_ELT(colNames, 0, mkChar(\"a\"));\n  SET_STRING_ELT(colNames, 1, mkChar(\"b\"));\n  SET_STRING_ELT(colNames, 2, mkChar(\"c\"));\n  SET_STRING_ELT(colNames, 3, mkChar(\"sum\"));\n  setAttrib(df, R_NamesSymbol, colNames);<\/code><\/pre>\n\n\n\n
and row names<\/p>\n\n\n\n
 SEXP rowNames;\n  PROTECT(rowNames = allocVector(STRSXP, nrows));\n  for (int i = 0; i < nrows; ++i) {\n    char rowName[11];\n    snprintf(rowName, sizeof(rowName), \"%10d\", i + 1\n    SET_STRING_ELT(rowNames, i, mkChar(rowName));\n  }\n  setAttrib(df, R_RowNamesSymbol, rowNames);<\/code><\/pre>\n\n\n\n
and the class itself<\/p>\n\n\n\n
  SEXP className;\n  PROTECT(className = allocVector(STRSXP, 1));\n  SET_STRING_ELT(className, 0, mkChar(\"data.frame\"));\n  classgets(df, className);<\/code><\/pre>\n\n\n\n
then finally UNPROTECT<\/code>ing the PROTECTED<\/code> objects and returning the data.frame<\/code><\/p>\n\n\n\n
  UNPROTECT(8);\n  return df;<\/code><\/pre>\n\n\n\n
At one point, I had forgotten that I had modified an example and now had more PROTECT<\/code> wrappers around objects, but hadn\u2019t updated the number in UNPROTECT<\/code>. It turns out this leads to an error in R about a stack imbalance – not particularly meaningful if you don\u2019t realise what that means, so FYI.<\/p>\n\n\n\n
So, with this new code<\/a> (github.com) in src\/triangles.c<\/code> we re-build and reload and try it out<\/p>\n\n\n\n
library(triangles)\n\nx <- triangles(16)\n\nx<\/code><\/pre>\n\n\n\n
##            a  b  c sum\n##          1 3  4  5  12\n##          2 6  8 10  24\n##          3 5 12 13  30\n##          4 9 12 15  36<\/code><\/pre>\n\n\n\n
str(x)\n<\/code><\/pre>\n\n\n\n
## 'data.frame':\t4 obs. of  4 variables:\n##  $ a  : int  3 6 5 9\n##  $ b  : int  4 8 12 12\n##  $ c  : int  5 10 13 15\n##  $ sum: int  12 24 30 36<\/code><\/pre>\n\n\n\n
Nothing printed when not expected, and the result is really a data.frame<\/code>! We can even work with the data now<\/p>\n\n\n\n
sum(x$sum)\n<\/code><\/pre>\n\n\n\n
## [1] 102<\/code><\/pre>\n\n\n\n
We still have the C code, and this can be updated as it evolves without affecting the R interface to it. With the R parts commented out, it can still be run as if it was just a regular C file. If we really<\/em> want to compile it with the R parts still there we can include the R libraries (on a linux system, for example) with<\/p>\n\n\n\n
$ cc -O -o triangle triangles.c -I\/usr\/share\/R\/include -L\/usr\/lib\/R\/lib -lR\n<\/code><\/pre>\n\n\n\n
Update 12-Aug-2023<\/strong>: I forgot to mention that in order to pass checks, R wants to have the following, typically in a file src\/init.c<\/code><\/a> (github.com)<\/p>\n\n\n\n
#include <R.h>\n#include <Rinternals.h>\n#include <stdlib.h> \/\/ for NULL\n#include <R_ext\/Rdynload.h>\n\n\/* .Call calls *\/\nextern SEXP C_triangles(SEXP maximum);\n\nstatic const R_CallMethodDef CallEntries[] = {\n  {\"C_triangles\", (DL_FUNC) &C_triangles, 1},\n  {NULL, NULL, 0}\n};\n\nvoid R_init_addr(DllInfo *dll) {\n  R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);\n  R_useDynamicSymbols(dll, FALSE);\n}<\/code><\/pre>\n\n\n\n
I won\u2019t say I understand this bit, but it is<\/em> mentioned in this part<\/a> (blog.davisvaughan.com) of Davis\u2019 post.<\/p>\n\n\n\n
I also updated the snprintf<\/code> call in the rownames assignment since I got a warning about truncation.<\/p>\n\n\n\n
There are some valid concerns about the fact that I\u2019m not explicitly free()<\/code>ing the allocated memory, so I plan to add some code to do that.<\/p>\n\n\n\n
As always, I\u2019ve learned a lot messing with things outside of my comfort zone here. I wouldn\u2019t say that I want to write a lot more C code, but at least now I feel somewhat comfortable bringing into R to work with.<\/p>\n\n\n\n
The package I detailed building here is on GitHub: https:\/\/github.com\/jonocarroll\/triangles<\/a> (github.com) in case it\u2019s useful to you.<\/p>\n\n\n\n
There\u2019s always more for me to learn, though, so if you have comments, feedback, suggestions for improvements, etc\u2026 I can be found on Mastodon<\/a> (fosstodon.org).<\/p>\n","protected":false},"excerpt":{"rendered":"
Those of you who know R really well probably know that the language itself is in no small part written in C.<\/p>\n","protected":false},"author":1279,"featured_media":199975,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[339,343,338,341,342],"tags":[2279,14403,487,16408,6591],"contributors-categories":[16353],"class_list":{"0":"post-199704","1":"post","2":"type-post","3":"status-publish","4":"format-standard","5":"has-post-thumbnail","7":"category-data-science","8":"category-programing-languages","9":"category-ibkr-quant-news","10":"category-quant-development","11":"category-r-development","12":"tag-c-5","13":"tag-chatgpt","14":"tag-r","15":"tag-roxygen","16":"tag-rstats","17":"contributors-categories-jonathan-carroll"},"pp_statuses_selecting_workflow":false,"pp_workflow_action":"current","pp_status_selection":"publish","acf":[],"yoast_head":"\nWrapping C Code in an R Package | IBKR Quant<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.interactivebrokers.com\/campus\/wp-json\/wp\/v2\/posts\/199704\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Wrapping C Code in an R Package\" \/>\n<meta property=\"og:description\" content=\"Those of you who know R really well probably know that the language itself is in no small part written in C.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/\" \/>\n<meta property=\"og:site_name\" content=\"IBKR Campus US\" \/>\n<meta property=\"article:published_time\" content=\"2023-12-12T14:12:34+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-12-15T20:40:07+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.interactivebrokers.com\/campus\/wp-content\/uploads\/sites\/2\/2023\/12\/blue-background-digits-hand.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1000\" \/>\n\t<meta property=\"og:image:height\" content=\"563\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Jonathan Carroll\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Jonathan Carroll\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"11 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\n\t    \"@context\": \"https:\\\/\\\/schema.org\",\n\t    \"@graph\": [\n\t        {\n\t            \"@type\": \"NewsArticle\",\n\t            \"@id\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/#article\",\n\t            \"isPartOf\": {\n\t                \"@id\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/\"\n\t            },\n\t            \"author\": {\n\t                \"name\": \"Jonathan Carroll\",\n\t                \"@id\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/#\\\/schema\\\/person\\\/c4fbe8e18075bc8536b7573e2dcb4561\"\n\t            },\n\t            \"headline\": \"Wrapping C Code in an R Package\",\n\t            \"datePublished\": \"2023-12-12T14:12:34+00:00\",\n\t            \"dateModified\": \"2023-12-15T20:40:07+00:00\",\n\t            \"mainEntityOfPage\": {\n\t                \"@id\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/\"\n\t            },\n\t            \"wordCount\": 2458,\n\t            \"commentCount\": 0,\n\t            \"publisher\": {\n\t                \"@id\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/#organization\"\n\t            },\n\t            \"image\": {\n\t                \"@id\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/#primaryimage\"\n\t            },\n\t            \"thumbnailUrl\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/wp-content\\\/uploads\\\/sites\\\/2\\\/2023\\\/12\\\/blue-background-digits-hand.jpg\",\n\t            \"keywords\": [\n\t                \"C\",\n\t                \"ChatGPT\",\n\t                \"R\",\n\t                \"Roxygen\",\n\t                \"rstats\"\n\t            ],\n\t            \"articleSection\": [\n\t                \"Data Science\",\n\t                \"Programming Languages\",\n\t                \"Quant\",\n\t                \"Quant Development\",\n\t                \"R Development\"\n\t            ],\n\t            \"inLanguage\": \"en-US\",\n\t            \"potentialAction\": [\n\t                {\n\t                    \"@type\": \"CommentAction\",\n\t                    \"name\": \"Comment\",\n\t                    \"target\": [\n\t                        \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/#respond\"\n\t                    ]\n\t                }\n\t            ]\n\t        },\n\t        {\n\t            \"@type\": \"WebPage\",\n\t            \"@id\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/\",\n\t            \"url\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/\",\n\t            \"name\": \"Wrapping C Code in an R Package | IBKR Campus US\",\n\t            \"isPartOf\": {\n\t                \"@id\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/#website\"\n\t            },\n\t            \"primaryImageOfPage\": {\n\t                \"@id\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/#primaryimage\"\n\t            },\n\t            \"image\": {\n\t                \"@id\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/#primaryimage\"\n\t            },\n\t            \"thumbnailUrl\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/wp-content\\\/uploads\\\/sites\\\/2\\\/2023\\\/12\\\/blue-background-digits-hand.jpg\",\n\t            \"datePublished\": \"2023-12-12T14:12:34+00:00\",\n\t            \"dateModified\": \"2023-12-15T20:40:07+00:00\",\n\t            \"inLanguage\": \"en-US\",\n\t            \"potentialAction\": [\n\t                {\n\t                    \"@type\": \"ReadAction\",\n\t                    \"target\": [\n\t                        \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/\"\n\t                    ]\n\t                }\n\t            ]\n\t        },\n\t        {\n\t            \"@type\": \"ImageObject\",\n\t            \"inLanguage\": \"en-US\",\n\t            \"@id\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/ibkr-quant-news\\\/wrapping-c-code-in-an-r-package\\\/#primaryimage\",\n\t            \"url\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/wp-content\\\/uploads\\\/sites\\\/2\\\/2023\\\/12\\\/blue-background-digits-hand.jpg\",\n\t            \"contentUrl\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/wp-content\\\/uploads\\\/sites\\\/2\\\/2023\\\/12\\\/blue-background-digits-hand.jpg\",\n\t            \"width\": 1000,\n\t            \"height\": 563,\n\t            \"caption\": \"Quant\"\n\t        },\n\t        {\n\t            \"@type\": \"WebSite\",\n\t            \"@id\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/#website\",\n\t            \"url\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/\",\n\t            \"name\": \"IBKR Campus US\",\n\t            \"description\": \"Financial Education from Interactive Brokers\",\n\t            \"publisher\": {\n\t                \"@id\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/#organization\"\n\t            },\n\t            \"potentialAction\": [\n\t                {\n\t                    \"@type\": \"SearchAction\",\n\t                    \"target\": {\n\t                        \"@type\": \"EntryPoint\",\n\t                        \"urlTemplate\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/?s={search_term_string}\"\n\t                    },\n\t                    \"query-input\": {\n\t                        \"@type\": \"PropertyValueSpecification\",\n\t                        \"valueRequired\": true,\n\t                        \"valueName\": \"search_term_string\"\n\t                    }\n\t                }\n\t            ],\n\t            \"inLanguage\": \"en-US\"\n\t        },\n\t        {\n\t            \"@type\": \"Organization\",\n\t            \"@id\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/#organization\",\n\t            \"name\": \"Interactive Brokers\",\n\t            \"alternateName\": \"IBKR\",\n\t            \"url\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/\",\n\t            \"logo\": {\n\t                \"@type\": \"ImageObject\",\n\t                \"inLanguage\": \"en-US\",\n\t                \"@id\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/#\\\/schema\\\/logo\\\/image\\\/\",\n\t                \"url\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/wp-content\\\/uploads\\\/sites\\\/2\\\/2024\\\/05\\\/ibkr-campus-logo.jpg\",\n\t                \"contentUrl\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/wp-content\\\/uploads\\\/sites\\\/2\\\/2024\\\/05\\\/ibkr-campus-logo.jpg\",\n\t                \"width\": 669,\n\t                \"height\": 669,\n\t                \"caption\": \"Interactive Brokers\"\n\t            },\n\t            \"image\": {\n\t                \"@id\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/#\\\/schema\\\/logo\\\/image\\\/\"\n\t            },\n\t            \"publishingPrinciples\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/about-ibkr-campus\\\/\",\n\t            \"ethicsPolicy\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/cyber-security-notice\\\/\"\n\t        },\n\t        {\n\t            \"@type\": \"Person\",\n\t            \"@id\": \"https:\\\/\\\/ibkrcampus.com\\\/campus\\\/#\\\/schema\\\/person\\\/c4fbe8e18075bc8536b7573e2dcb4561\",\n\t            \"name\": \"Jonathan Carroll\",\n\t            \"url\": \"https:\\\/\\\/www.interactivebrokers.com\\\/campus\\\/author\\\/jonathancarroll\\\/\"\n\t        }\n\t    ]\n\t}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Wrapping C Code in an R Package | IBKR Quant","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.interactivebrokers.com\/campus\/wp-json\/wp\/v2\/posts\/199704\/","og_locale":"en_US","og_type":"article","og_title":"Wrapping C Code in an R Package","og_description":"Those of you who know R really well probably know that the language itself is in no small part written in C.","og_url":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/","og_site_name":"IBKR Campus US","article_published_time":"2023-12-12T14:12:34+00:00","article_modified_time":"2023-12-15T20:40:07+00:00","og_image":[{"width":1000,"height":563,"url":"https:\/\/www.interactivebrokers.com\/campus\/wp-content\/uploads\/sites\/2\/2023\/12\/blue-background-digits-hand.jpg","type":"image\/jpeg"}],"author":"Jonathan Carroll","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Jonathan Carroll","Est. reading time":"11 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"NewsArticle","@id":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/#article","isPartOf":{"@id":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/"},"author":{"name":"Jonathan Carroll","@id":"https:\/\/ibkrcampus.com\/campus\/#\/schema\/person\/c4fbe8e18075bc8536b7573e2dcb4561"},"headline":"Wrapping C Code in an R Package","datePublished":"2023-12-12T14:12:34+00:00","dateModified":"2023-12-15T20:40:07+00:00","mainEntityOfPage":{"@id":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/"},"wordCount":2458,"commentCount":0,"publisher":{"@id":"https:\/\/ibkrcampus.com\/campus\/#organization"},"image":{"@id":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/#primaryimage"},"thumbnailUrl":"https:\/\/www.interactivebrokers.com\/campus\/wp-content\/uploads\/sites\/2\/2023\/12\/blue-background-digits-hand.jpg","keywords":["C","ChatGPT","R","Roxygen","rstats"],"articleSection":["Data Science","Programming Languages","Quant","Quant Development","R Development"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/","url":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/","name":"Wrapping C Code in an R Package | IBKR Campus US","isPartOf":{"@id":"https:\/\/ibkrcampus.com\/campus\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/#primaryimage"},"image":{"@id":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/#primaryimage"},"thumbnailUrl":"https:\/\/www.interactivebrokers.com\/campus\/wp-content\/uploads\/sites\/2\/2023\/12\/blue-background-digits-hand.jpg","datePublished":"2023-12-12T14:12:34+00:00","dateModified":"2023-12-15T20:40:07+00:00","inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.interactivebrokers.com\/campus\/ibkr-quant-news\/wrapping-c-code-in-an-r-package\/#primaryimage","url":"https:\/\/www.interactivebrokers.com\/campus\/wp-content\/uploads\/sites\/2\/2023\/12\/blue-background-digits-hand.jpg","contentUrl":"https:\/\/www.interactivebrokers.com\/campus\/wp-content\/uploads\/sites\/2\/2023\/12\/blue-background-digits-hand.jpg","width":1000,"height":563,"caption":"Quant"},{"@type":"WebSite","@id":"https:\/\/ibkrcampus.com\/campus\/#website","url":"https:\/\/ibkrcampus.com\/campus\/","name":"IBKR Campus US","description":"Financial Education from Interactive Brokers","publisher":{"@id":"https:\/\/ibkrcampus.com\/campus\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/ibkrcampus.com\/campus\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/ibkrcampus.com\/campus\/#organization","name":"Interactive Brokers","alternateName":"IBKR","url":"https:\/\/ibkrcampus.com\/campus\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/ibkrcampus.com\/campus\/#\/schema\/logo\/image\/","url":"https:\/\/www.interactivebrokers.com\/campus\/wp-content\/uploads\/sites\/2\/2024\/05\/ibkr-campus-logo.jpg","contentUrl":"https:\/\/www.interactivebrokers.com\/campus\/wp-content\/uploads\/sites\/2\/2024\/05\/ibkr-campus-logo.jpg","width":669,"height":669,"caption":"Interactive Brokers"},"image":{"@id":"https:\/\/ibkrcampus.com\/campus\/#\/schema\/logo\/image\/"},"publishingPrinciples":"https:\/\/www.interactivebrokers.com\/campus\/about-ibkr-campus\/","ethicsPolicy":"https:\/\/www.interactivebrokers.com\/campus\/cyber-security-notice\/"},{"@type":"Person","@id":"https:\/\/ibkrcampus.com\/campus\/#\/schema\/person\/c4fbe8e18075bc8536b7573e2dcb4561","name":"Jonathan Carroll","url":"https:\/\/www.interactivebrokers.com\/campus\/author\/jonathancarroll\/"}]}},"jetpack_featured_media_url":"https:\/\/www.interactivebrokers.com\/campus\/wp-content\/uploads\/sites\/2\/2023\/12\/blue-background-digits-hand.jpg","_links":{"self":[{"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/posts\/199704","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/users\/1279"}],"replies":[{"embeddable":true,"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/comments?post=199704"}],"version-history":[{"count":0,"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/posts\/199704\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/media\/199975"}],"wp:attachment":[{"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/media?parent=199704"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/categories?post=199704"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/tags?post=199704"},{"taxonomy":"contributors-categories","embeddable":true,"href":"https:\/\/ibkrcampus.com\/campus\/wp-json\/wp\/v2\/contributors-categories?post=199704"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}