参考for循环

Question

的对象列表说我有两个对象，a和b，和R中的函数f1

a<- 5 
b<- 10 

f1<-function(){ 
    out<- a+b 
    return(out) 

我想写一个for循环，评估此功能的灵敏度到a和b各改变它们，并再次运行函数的值。我想创建对象的载体中，然后运行一些像这样的代码：

params<- c(a,b) 
for(i in params){ 
    store<- i   #save the initial value of the object so I can restore it later. 
    base<-f1()   #save function output with original object value 
    i<- i*1.1   #increase object value by 10% 
    base.10<- f1()  #recalculate and save function output with new object value 
    calc<- base.10/base #generate a response metric 
    i<- store   #reset the object value to its original value 
    return(calc)  
} 

Answer 1

这听起来像你有一个函数f1依靠对象a和b（未在函数定义），并且你想要测试其输出的灵敏度值为a和b。接近这会通过你想要的敏感性分析的值来循环和操作的f1父环境的一种方式，因此使用这些值：

f1 <- function() a + b 
sensitivity <- function(params) { 
    old.f1.env <- environment(f1) 
    grid <- expand.grid(lapply(params, function(x) x * c(1, 1.1))) 
    grid$outcome <- apply(grid, 1, function(x) { 
    for (n in names(x)) { 
     assign(n, x[n]) 
    } 
    environment(f1) <- environment() 
    ret <- f1() 
    environment(f1) <- old.f1.env 
    ret 
    }) 
    grid 
} 
sensitivity(list(a=5, b=10)) 
#  a b outcome 
# 1 5.0 10 15.0 
# 2 5.5 10 15.5 
# 3 5.0 11 16.0 
# 4 5.5 11 16.5 

在这里，我们进行计算的函数值一格的a和b值，无论是在原始a和b值和在10％的增加的值。

请注意，我们的很多工作都来自于f1父环境指定的变量。我鼓励你重构你的代码，所以你的函数f1将相关参数作为输入。那么你可以使用：

f1 <- function(a, b) a + b 
sensitivity <- function(params) { 
    grid <- expand.grid(lapply(params, function(x) x * c(1, 1.1))) 
    grid$outcome <- apply(grid, 1, function(x) do.call(f1, as.list(x))) 
    grid 
} 
sensitivity(list(a=5, b=10)) 
#  a b outcome 
# 1 5.0 10 15.0 
# 2 5.5 10 15.5 
# 3 5.0 11 16.0 
# 4 5.5 11 16.5 

Answer 2

这听起来像是一个完美的封闭用例。

get_f1 <- function(a, b) { 
    f1<-function(){ 
     out<- a+b 
     return(out) 
    } 
    return(f1) 
} 

然后：

my_f1 <- get_f1(a=5, b=10) 
my_f1() #uses a=5 and b=10 because they are defined in the envir associated with my_f1 

所以在你的循环，你可以简单地做：

base <- (get_f1(a, b))() 
base.10 <- (get_f1(a*1.1, b*1.1))()  

很明显，你可以带参数i=c(a, b)定义get_f1。

使用闭包（连接到环境功能），而不是与环境摆弄！

TL;博士：闭包是真棒

Answer 3

读你的一些意见，我觉得这其实是你想要什么：sensitivity需要的功能和参数列表和返回功能，它的参数的敏感性。（顺便说一句，你叫什么敏感性，已经意味着something else）

sensitivity <- function(fun, args) { 
    out <- lapply(names(args), function(cur) { 
     base10 <- do.call(fun, `[[<-`(args, cur, `[[`(args,cur)*1.1)) 
     base10/do.call(fun, args) 
    }) 
    names(out) <- names(args) 
    return(out) 
} 

例子：

f1 <- function(a,b) a+b 
a1 <- list(a=5, b=2) 
sensitivity(f1, a1) 

这给

$a 
[1] 1.03 

$b 
[1] 1.07 

例2：

f2 <- function(x, y, z) x^2 +3*y*z 
sensitivity(f2, list(x=1, y=2, z=3)) 


$x 
[1] 1.011053 

$y 
[1] 1.094737 

$z 
[1] 1.094737 

它的工作原理“插件并且玩“wi任何函数，但它需要你以不同的方式定义f（人们会说，正确）。我写可能写一些可以与你的函数一起工作的东西，因为它是写的，但它会有很多工作和不好的口味。如果你想要的代码模块，你就不能使用副作用...

PS：如果你希望有一个向量返回而不是一个列表，只需在sensitivity清晰度改变lapply到sapply。

这将给出最后的示例：

> sensitivity(f2, list(x=1, y=2, z=3)) 
     x  y  z 
1.011053 1.094737 1.094737 

PPS：任何理由，你为什么不计算f的梯度，而不是做你在做什么？