2

我的 for 循环应该在 1000 的时间段内每 50 次执行一次,在 matlab 中有这样的 1:50:1000 我们在 R 中有什么类似的东西吗?请让我知道从 1 开始,增量为 50 到 1000

4

2 回答 2

3

该函数有一个by 参数seq

R> seq(0,1000,by=50)
 [1]    0   50  100  150  200  250  300  350  400  450  500  550  600  650
[15]  700  750  800  850  900  950 1000

所以你可以使用:

R> for (i in seq(0,1000,by=50)) print(i)
[1] 0
[1] 50                                                                                                                                                               
[1] 100                                                                                                                                                              
[1] 150                                                                                                                                                              
[1] 200                                                                                                                                                              
[1] 250                                                                                                                                                              
[1] 300                                                                                                                                                              
[1] 350                                                                                                                                                              
[1] 400                                                                                                                                                              
[1] 450                                                                                                                                                              
[1] 500                                                                                                                                                              
[1] 550                                                                                                                                                              
[1] 600                                                                                                                                                              
[1] 650                                                                                                                                                              
[1] 700                                                                                                                                                              
[1] 750                                                                                                                                                              
[1] 800                                                                                                                                                              
[1] 850                                                                                                                                                              
[1] 900                                                                                                                                                              
[1] 950                                                                                                                                                              
[1] 1000   
于 2013-09-26T07:21:38.090 回答
1

编辑 - 使用apply(无循环)可能是最干净的解决方案:

apply(stored[seq(1,1000,50), ], 1, yourfunction) # 其中 1 表示超过行。

使用模(循环)

我通常的做事方式是使用模数来获得所需的行为。例如,每 50 次迭代打印一次迭代,同时对每次迭代执行一些操作:

stored <- 1:1000
for (i in 1:1000) {
 stored[i] <- rnorm(1)
 if (i %% 50 == 0) { print(i) }
}

这将允许完全控制,因为您还可以每次执行其他操作,例如通过添加另一个迭代 100 次if i modulo x == 0, then ...

序列方法的问题是你不能在循环中有效地存储:

stored <- 1:1000
for (i in seq(0,1000,by=50)) {
 stored[i] <- rnorm(1)
 print(i)
}

打印会很好,但结果向量将是:

  [1]          NA          NA          NA          NA          NA          NA
   [7]          NA          NA          NA          NA          NA          NA
  [13]          NA          NA          NA          NA          NA          NA
  [19]          NA          NA          NA          NA          NA          NA
  [25]          NA          NA          NA          NA          NA          NA
  [31]          NA          NA          NA          NA          NA          NA
  [37]          NA          NA          NA          NA          NA          NA
  [43]          NA          NA          NA          NA          NA          NA
  [49]          NA -0.73339457  ....  ...    ... etc

为了解决这个问题,你还必须做一些除法,所以我发现只使用普通循环然后使用模来进行完美控制是最有效的。

使用sapply(无循环)

正如您在评论中指出的那样,您想要实际存储一些东西,为此,序列上的循环会给您留下漏洞。所以你可以使用sapply(申请家庭文件,阅读这个

通常,可以使用sapply(1:1000, function(x) mean(stored[x,])),函数可以是任何东西。如果您希望每次迭代都可以使用 colMeans 之类的快捷方式。

但是,由于您需要一个序列,您可以使用sapply, 并为其提供变量参数。

seqMean <- function(x) {
   mean(stored[x,])
}

sapply(seq(1,1000,50), function(x) seqMean(x))

或简而言之:

sapply(seq(1,1000,50), seqMean)
于 2013-09-26T07:29:51.687 回答