Pass vector as multiple parameters (as in python f(*x))

f <- function(x,y,z) x+y+z
args<-alist(x=5,y=6,z=7)
formals(f) <- args
f()

Thanks Bert, do.call is exactly what I was looking for. What in lisp
is apply and in python f(*v).

Your whole premise that the arguments of a function should be mappable to elements of a vector seems contrary to good R programming practice.

Jeff I didn't pretend to imply that the mapping should by always
possible. lists for positional arguments and named lists for named
arguments would do the trick most of the times. It's pretty common in
dynamic languages.

That said, the specific task I have in mind is to index an array of an
arbitrary dimension n by a list of length n vectors, each one
representing <x1,...,xn> coordinates.

For example, if n=2, the array is the matrix m, and the list of vectors is vs:

m=matrix(1:16,4)
vs = list(c(2,3),c(2,2),c(1,1))

Then do.call would allow me to index m as follows:

lapply(vs, function(v) { do.call(`[`, append(list(m), v)) })

Alternatively:

f = function (...) { m[...] }
lapply(vs, function(v) { do.call(f, as.list(v)) })

Of course, I could just do m[v[1],v[2]] in this case, but the point is
that the dimension n would be a parameter of my function, not a
constant.

But if you know of a better or more r-esque solution I would be very
glad to hear of it.

Best regards
--
Carlos


Best regards
--
Carlos

Consider changing the called function's handling of arguments instead
to accept the vector of data directly if a vector makes sense, or to a
list if the arguments have a variety of types.

---------------------------------------------------------------------------
Jeff Newmiller                        The     .....       .....  Go Live...
DCN:<jdnewmil at dcn.davis.ca.us>        Basics: ##.#.       ##.#.  Live Go...
                                      Live:   OO#.. Dead: OO#..  Playing
Research Engineer (Solar/Batteries            O.O#.       #.O#.  with
/Software/Embedded Controllers)               .OO#.       .OO#.  rocks...1k
---------------------------------------------------------------------------
Sent from my phone. Please excuse my brevity.

Carlos Pita <carlosjosepita at gmail.com> wrote:

Hi,

I want to know if it's possible to pass a vector v=c(x,y,...) to a
function f(x,y,...) so that each vector element corresponds to a
formal argument of the function. For python programmers: f(*v).

Specifically, what I'm trying to achieve is: given a list of
coordinates l=list(c(x1,y1,z1), c(x2,y2,z2),...) I would like to
obtain the corresponding elements in some array A (3-dim in this
case). That is: A[x1,y1,z1], A[x2,y2,z2],....

One way would be to transform l=list(c(x1,y1,z1), c(x2,y2,z2),...) to
l2=list(c(x1,x2,...),c(y1,y2,...),c(z1,z2,...)) and then (if this is
possible at all) execute the equivalent to A[*l2].

Another way would be to lapply function(xyz) { A[*xyz] } to each
coordinate vector in l. In any case I need the f(*v) equivalent.

Please take into account that, despite the 3-dim example, I need to
implement the above to accept n-dim vectors for arbitrary n, so
something like x<-xyz[1], y<-xyz[2], z<-xyz[3] wouldn't fit the bill.

Any other suggested solution would be appreciated.

Best regards
--
Carlos