将嵌套循环与嵌套列表一起使用

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 （如果将n增加到100，则不能为0.01 ）。

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))