对嵌套列表使用嵌套循环

Question

我正在尝试使用嵌套列表和嵌套循环将值与阈值进行比较。该列表包含一个个人列表，每个人都获得 n 次试验，其中（在每次试验中）他们获得两个值，这些值来自两个分布。然后使用 Kullback-Leibler 散度 (KLD) 组合这些值，这意味着每个试验现在都有一个值。目标是找出（对于每个人）这些值中有多少等于或超过阈值。

问题是结果不相符。当阈值为 0.5（根据我的计算）时，我应该得到很多 1（在我的 compare_05 中）。对我做错了什么有什么建议吗？我是非常编码新手，所以代码可能看起来有点粗糙。

n = 10#trials
x = 5#people

p_sd = 1
s_sd = 0.5
KL_sd = 0.4472136

rand_values = list(1:2)
trials = list(rep(rand_values,n))
all_1 = rep(trials, x) #nested lists

for (i in 1:x){
  for (k in 1:n){
    for (m in 1:2){
      if (all_1[[i]][[k]][[m]]==1){
        all_1[[i]][[k]][[m]]=rnorm(1,0,2) #adding the random values
      } else {
        all_1[[i]][[k]][[m]]=rnorm(1,0,1)
      }
    }
  }
}

compare_05=numeric(x)
for (i in 1:x){
  for (k in 1:n){
    compare_05[i]=length(which(   #the next seven lines make up the KLD equation
      (log(p_sd/KL_sd) + (((KL_sd*KL_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                     (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
           (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*p_sd*p_sd))-0.5 
   +  
      log(KL_sd/p_sd) + (((p_sd*p_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                    (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
       (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*KL_sd*KL_sd))-0.5)
      >=0.5))/n 
  }
}

当我使用 cohen 的 d 而不是 KLD 组合随机抽取的值时，我完成了这项工作。

all_2 = all_1
for (i in 1:x){
  for (k in 1:n){
    all_2[[i]][k]=sum(all_2[[i]][[k]][[1]]-all_2[[i]][[k]][[2]])
    all_2[[i]][k]=abs(all_2[[i]][[k]][[1]]/0.7905)
  }
}

compare_d_05 = numeric(x)
for (i in 1:x){
  compare_d_05[i]=length(which((as.numeric(all_2[[i]]))>=0.5))/n
}

科恩 d (compare_d_05) 的结果：

[1] 0.8 0.9 0.8 0.9 0.9

我不希望输出与这些数字相似（除非你将阈值增加到 2.5 或 2.75），但我绝对不应该得到很多 0.1（或 0.01 如果将 n 增加到 100)。

Answer 1

当您定义 compare_05[i] 时，它会为每个 k 重新定义，因此您实际上是在执行以下操作

compare_05=numeric(x)
for (i in 1:x){
  for (k in n){#Only where k is n, not for other values of k
    compare_05[i]=length(which(   #the next seven lines make up the KLD equation
      (log(p_sd/KL_sd) + (((KL_sd*KL_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                     (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
           (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*p_sd*p_sd))-0.5 
   +  
      log(KL_sd/p_sd) + (((p_sd*p_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                    (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
       (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*KL_sd*KL_sd))-0.5)
      >=0.5))/n 
  }
}

cohen 的 d 不会发生这种情况，因为您只在那里使用了一个循环。如果我没理解错的话，你想要的是类似下面的东西：

kld<-function(k, i, all_1){
  length(
    which(
      (log(p_sd/KL_sd)+(((KL_sd*KL_sd)+(all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                                                                (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
                                                                (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*p_sd*p_sd))-0.5 
       +  
         log(KL_sd/p_sd) + (((p_sd*p_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                                                                    (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
                                                                    (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*KL_sd*KL_sd))-0.5
    )>=0.5))/n
}

compare_05=numeric(x)
for(i in 1:x){
  compare_05[i]<-sum(unlist(lapply(1:10, kld, i, all_1)))
}

一个更短的替代方案，无需使用循环，将是：

compare_05<-unlist(lapply(1:x, function(a, b, all_1)
  sum(unlist(lapply(1:b, kld, a, all_1))), n, all_1))

对嵌套列表使用嵌套循环

Using nested loops with nested lists

r

nested-loops