рекурсивная сумма плюс произведение в г

Question

У меня есть кадр данных в R, который состоит из двух (числовых) столбцов, скажем А и В. Я хотел бы конструктору столбец, состоящий из элементов

A1+B1 
(A1+B1)*A2+B2 
((A1+B1)*A2+B2)*A3+B3 
    ... 

Это, вероятно, это простой однострочный, но я этого не вижу.

Редактировать: удалил слово, обозначенное в заголовке, так как меня просто интересует любое элегантное решение (тупые, которые я могу сделать сам). В F # - который я больше знакомы с - это было бы что-то вроде (предполагается, что элементы будут находиться в списке как кортежей, который был бы более идиоматических):

ABlist |> List.fold (fun acc (a,b) -> acc*a+b) 1 

Что еще что-то очень коротко и ясно , Я перетаскиваю это, потому что я R noob и не знаком с ним, но я где-то читал, что это функциональный язык, поэтому я бы предположил, что решение с точки зрения фрейма над кадром данных будет существовать?

Answer 1

Это другой ответ обусловлен провалом усилий Брэма в использовании Сокращения. Он строит список, который имеет A, B пару, а затем устанавливает intial значения для аккумулятора на 1, так что первое умножение не получает обнуляется:

abList <- mapply(c, A,B, SIMPLIFY=FALSE) # keeps as a list 
Reduce(function(acc,x) {acc*x[1]+x[2]}, 
     abList,init=c(1,0), 
     accumulate=TRUE)[-1]    # removes the initialization value 
#-------- 
[[1]] 
[1] 4 3 

[[2]] 
[1] 10 8 

[[3]] 
[1] 31 25 

[[4]] 
[1] 128 104 

[[5]] 
[1] 645 525 

может занять некоторую дальнейшую работу с s/lapply(..., "[", 1) тянуть из аккумулятора

> sapply(Reduce(function(acc,x) {acc*x[1]+x[2]}, 
+   abList,init=c(1,0), 
+   accumulate=TRUE)[-1], "[", 1) 
[1] 4 10 31 128 645 

Answer 2

Это является относительно простым в Rcpp, который не будет иметь проблем с производительностью вы увидели бы, если вы попытаетесь реализовать это с петлями в R.

library(Rcpp) 
sum.prod <- cppFunction(
"NumericVector sum_prod(NumericVector x, NumericVector y) { 
    NumericVector result(x.size()); 
    result[0] = x[0] + y[0]; 
    for (int i=1; i < x.size(); ++i) result[i] = result[i-1]*x[i] + y[i]; 
    return result; 
}") 
sum.prod(c(1, 2, 3, 4, 5), c(3, 2, 1, 4, 5)) 
# [1] 4 10 31 128 645 

Я нашел Rcpp быть самым простым способом для ускорения вычислений с большой точностью для векторизации.

Answer 3

Хорошо, оказалось, что я был слишком ленив, я сам это понял (заметьте: перед этим был хороший ответ, используя Rcpp уже, но я не могу использовать это на работе). В основном только перевод на R, что я написал в моем редактирования того, как я хотел бы сделать это в F #:

a <- c(1,2,3) 
b <- c(4,5,6) 
abList <- list(a,b) 
Reduce(function(acc,x) {acc*x[[1]]+x[[2]]}, 
     abList, 
     accumulate=TRUE) 

ли трюк. Изменить: согласно приведенному ниже комментарию, на самом деле это не делает трюк. Если одна сборка abList по

abList <- apply(rbind(a,b),2,as.pairlist) 

, а затем складывает по:

Reduce(function(acc,x) {(acc*x[[1]])+x[[2]]},abList,1,accumulate=TRUE) 

Один получает правильный ответ (с 1 вставляться перед, потому что это intial значение для аккумулятора)

Answer 4

X = 1; for (i in seq(length(A))) { X= B[i]+A[i]*X; print(X) } 
[1] 4 
[1] 10 
[1] 31 
[1] 128 
[1] 645 

Если вы хотите скопировать, а не повторить:

X = 1; for (i in seq(length(A))) { X[1+i]= B[i]+A[i]*X[i] }; X[-1] 
#[1] 4 10 31 128 645 

Будет ploddingly медленным по сравнению с раствором Rcpp, но если вам нужно сделать шаг компиляции на лету это только тогда, когда длина более чем 1000, которые вы можете даже заметить разницу:

> A <- sample(1:10000, 1000); B <- sample(1:10000, 1000) 
> system.time({X = 1; for (i in seq(length(A))) { X[1+i]= B[i]+A[i]*X[i] }; X[-1]}) 
    user system elapsed 
    0.014 0.002 0.017 
> library(Rcpp) 
> system.time({sum.prod <- cppFunction(
+ "NumericVector sum_prod(NumericVector x, NumericVector y) { 
+ NumericVector result(x.size()); 
+ result[0] = x[0] + y[0]; 
+ for (int i=1; i < x.size(); ++i) result[i] = result[i-1]*x[i] + y[i]; 
+ return result; 
+ }") 
+ sum.prod(A,B) }) 
    user system elapsed 
    0.012 0.002 0.014