Question

我的for循环应该在1000的时间段内每隔50次执行一次，在matlab中有这样的事情：1：50：1000我们在R中有什么类似的吗？请告诉我从一个开始，增量为50，直到1000

Answer 1

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

Answer 2

编辑 - 使用apply（无循环）可能是最干净的解决方案：

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

使用modulo（循环）

我通常的做事方式是使用modulo来获取所需的行为。例如，在每次迭代时执行一些操作时，每50次迭代打印一次迭代：

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

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

进行100次迭代

序列方法的问题在于你无法有效地存储在循环中：

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

要解决这个问题，你还需要进行一些划分，所以我发现使用普通循环然后使用modulo进行完美控制是最有效的。

使用sapply（无循环）

正如你在评论中指出的那样，你想要实际存储一些东西，为此，一个序列上的循环会给你带来漏洞。因此，您可以使用sapply（申请家庭文档，阅读this）

通常，可以使用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)

R中的for循环跳过一些迭代

2 个答案: