如何避免在 R 中的用户定义函数上使用 sapply()

Question

I am a beginner with R programming. Recently I wrote a user-defined function as follows:

foo <- function(x){
power <- 1:4
sum(x^power)
}

This function works fine when x is a single number. For example, when x = 1 , the result is 4 and when x = 10 the result is 11110. However, this function doesn't work with vectors. For example, when x <- c(1, 10) , the result is 10102 which is not what I want. My desire result is a vector such as 4 11110 . I know this problem can be solved by using sapply() on function or add a for-loop inside the function, but I think there might be another way to rewrite the function without using loops or "apply" functions. I have tried different ways to rewrite the function but nothing works, can somebody help me to solve the problem? Thanks!

Answer 1

Mathematically, a simple and more straightforward approach is to rewrite foo function like below

foo <- function(x) {
  power <- 1:4
  ifelse(x==1,max(power),x*(x**(max(power))-1)/(x-1))
}

which gives

> foo(c(1,10))
[1]     4 11110

Answer 2

I don't think there is a way to avoid any kind of implicit or explicit loop since power is a vector and you are passing x to it which is another vector.

Here are few options:

1. Your best bet is sapply (which you have already figured out).

sapply(c(1, 10), foo)
#[1]     4 11110

2. Another way is to use Vectorize where you cannot "see" the loop but it still loop beneath as it is a wrapper to mapply .

Vectorize(foo)(c(1, 10))
#[1]     4 11110

3. Using outer :

foo <- function(x){
  power <- 1:4
  rowSums(outer(x, power, `^`))
}
foo(c(1, 10))
#[1]     4 11110

and obviously you can write a simple for loop as well and pass c(1, 10) to it.

Answer 3

This works:

foo <- function(x, power = 1:4){
  
  ind <- 1 + seq_along(power)
  power <- matrix(rep(power, length(x)), nrow = length(x), byrow = T)
  x <- as.matrix(x)
  
  m <- cbind(x, power)
  m <- m[, 1]^m[, ind]
  v <- rowSums(m)
  
  return(v)
  
}

foo(x = c(1, 10))
## [1]     4 11110

Runs about 8.5x faster than using sapply(x foo) (when foo is a vector of length == 1,000,000). It's a bit late here, so I don't know whether you could optimise the internals a little better.