# Re: [R] again, a question between R and C++

From: Whit Armstrong <whit_at_twinfieldscapital.com>
Date: Thu 21 Jul 2005 - 22:25:25 EST

Jordi,

The place to ask this question is probably the r-devel list; it's a little too heavy for r-help.

This is fairly easy to do using the .Call interface.

Have a look at lapply2 in the Writing R Extensions manual. http://cran.r-project.org/doc/manuals/R-exts.html#Evaluating-R-expressio ns-from-C

or just follow this short example.

write a function in C++ as follows:

SEXP myFunc(SEXP list1, SEXP list2, SEXP list3, SEXP list4, SEXP intID_SEXP) {

// obtain the list length as follows:

int list1_len = length(list1);

// to access your integer (I assume it's a scalar, not a vector)
// you need to grab the first element of this integer vector
int INTEGER(intID_SEXP)

// you will want to add some checks to make sure the arguments
are of the right type

```	...
...

SEXP ans = (whatever)
return ans;
```

}

you can call it in R as follows:

.Call("myFunc", list1, list2, list3, list4, intID)

-----Original Message-----
From: r-help-bounces@stat.math.ethz.ch
[mailto:r-help-bounces@stat.math.ethz.ch] On Behalf Of Molins, Jordi Sent: Thursday, July 21, 2005 3:25 AM
To: r-help@stat.math.ethz.ch
Cc: Jordi Molins
Subject: [R] again, a question between R and C++

Dear R Users,

I want to make a call from R into C++. My inputs are List1, List2, List3, IntegerID. The amount of elements of the lists and their type depend on IntegerID. Typical elements of a given list can be vectors, doubles, and even other lists. I want to return also a list (whose nature will depend also, possibly, on IntegerID).

What I want to do is to call these 4 inputs from C++ and then use a factory pattern (depending on IntegerID) that will perform different calculations on the lists depending on the IntegerID (of course, I could also do this with a simple switch statement).

I have been reading the documentation, especially the one regarding .Call and .External, and it seems that my algorithm could be implemented, but the examples I have seen up to now are such that what occupies the place of my lists are just vectors (like in convolve4 example).

Is there an example where I could see how instead of a vector, a set of lists (with an unkown number of arguments, as well as unkown types) are used as inputs? I guess that the ideal would be that in the equivalent of the
convolve4 function, my args would be "variant" type of lists, and then, after the factory pattern is called, and the correct class is registered (via IntegerID), this variant type is really "decomposed" into the individual types that compose the list (ie, vectors, doubles, ...). Of course, in the factory there should be as many "decomposing" algorithms as IntegerIDs, each creating a particular decomposition.

Also, how returning a list (whose nature will depend also, possibly, on IntegerID) should be handled?