add 36

36/paper.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae326c505eaed43328dd88b15847f631880b1e6ffcd1fe45226d5e3400d5d563
+size 923599

36/replication_package/README.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:778ec95c61e38a20b546da5eb725cb4d9e3607e0f9199eeae3a5e7358c5e12fb
+size 6762

36/replication_package/categorized_studies.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfd1e876427672061ffd0b763bd74a42a513343fb343dc872e6448e1ec518db1
+size 150770

36/replication_package/cces_matched_data.rds

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e457a36519c2a2141b98e23a66e89dd697c2623d29c4b7bfe6a3673fab0017a
+size 19492

36/replication_package/cces_unmatched_data.rds

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:527c134f2f9f40b52f4f3677a3f8edb3c552fe5583cb9d44739583c9ba7f9a8f
+size 28969

36/replication_package/codebook.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fa15149248ecf8c6d985b8f953f3d274f12f43164942ef45f4f35c921e23743
+size 316909

36/replication_package/lucid_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e908953ac6a81862b2170a41d0fdf442d9f52f547526787f6cf4f82842d7c992
+size 734289

36/replication_package/post.R

@@ -0,0 +1,493 @@
+####### post #######
+
+setGeneric("post", 
+           function(model,x1name=NULL,x1vals=NULL,x2name=NULL,x2vals=NULL,holds=NULL,
+                    n.sims=1000,cut=NULL,quantiles=c(.025,.975),did=NULL,weights=NULL, digits=2){
+             standardGeneric("post")
+           }
+)
+
+setClassUnion("arrayORNULL", c("array","NULL"))
+setClassUnion("listORcharacter", c("list","character"))
+
+setClass("post", 
+         slots = c(est = "array", 
+                   did = "arrayORNULL", 
+                   sims = "array", 
+                   model = "character", 
+                   link = "listORcharacter", 
+                   quantiles = "numeric", 
+                   call = "call")
+)
+
+
+post.glm <- function(model,x1name=NULL,x1vals=NULL,x2name=NULL,x2vals=NULL,holds=NULL,
+                     n.sims=1000,cut=NULL,quantiles=c(.025,.975),did=NULL,weights=NULL, digits=2){
+  
+  call <- match.call()
+  
+  sims <- postSim(model, n.sims=n.sims)
+  
+  if (family(model)[2]=="identity"){link <- identity} 
+  else if (family(model)[2]=="probit"){link <- pnorm}
+  else if (family(model)[2]=="logit"){link <- plogis}
+  else if (family(model)[2]=="log"){link <- exp}
+  else if (family(model)[2]=="cloglog"){link <- function(x){1-exp(-exp(x))}}
+  else {stop("Link function is not supported")}
+  
+  if (is.null(weights)){wi <- c(rep(1, length(model$model[,1])))} else{wi <- weights}
+  n.obs <- length(model.matrix(model)[,1])
+  k <- length(model.matrix(model)[1,])
+  n.q <- length(quantiles)
+  
+  if (is.null(x1name)){
+    X <- array(NA, c(n.obs,k))
+    newdata <- data.frame(model$model)
+    if (!is.null(holds)){
+      for (i in 1:length(holds)){
+        newdata[ ,names(holds)[i]] <- as.numeric(holds[i])
+      }
+    }
+    X <- aperm(model.matrix(lm(formula(model), data=newdata)))
+    l1 <- array(NA, c(nrow(sims@coef),1))
+    l1[,1] <- apply(link(sims@coef %*% X), 1, function(x) weighted.mean(x, wi))
+    l2 <- array(NA, c(1,n.q+1))
+    l2[1,1] <- mean(l1)
+    l2[1,2:(n.q+1)] <- quantile(l1, probs=quantiles)
+    colnames(l2) <- c("mean",quantiles)
+    
+    ans <- new("post", 
+               est=round(l2, digits=digits),
+               did=NULL,
+               sims=l1, 
+               model=class(model), 
+               link=family(model)[2], 
+               quantiles=quantiles, 
+               call=call)
+    return(ans)
+  }
+  
+  else if (is.null(x2name)){
+    
+    n.x1 <- length(x1vals)
+    X <- array(NA, c(n.obs,k,n.x1))
+    
+    for (i in 1:(n.x1)){
+      newdata <- data.frame(model$model)
+      if (!is.null(holds)){
+        for (j in 1:length(holds)){
+          newdata[ ,names(holds)[j]] <- as.numeric(holds[j])
+        }
+      }
+      newdata[ ,x1name] <- x1vals[i]
+      X[ , ,i] <- model.matrix(lm(formula(model), data=newdata))
+    }
+    
+    X <- aperm(X, c(2,1,3))
+    l1 <- apply(apply(X, c(2,3), function(x) link(sims@coef %*% x)), c(1,3), function(x) weighted.mean(x, wi))
+    l2 <- array(NA, c(n.x1+1,n.q+1))
+    l2[1:n.x1,1] <- apply(l1, 2, mean)
+    l2[1:n.x1,2:(n.q+1)] <- aperm(apply(l1, 2, function(x) quantile(x, probs=quantiles)))
+    
+    l2[nrow(l2),1] <- mean(l1[ ,n.x1] - l1[ ,1])
+    l2[nrow(l2),2:(n.q+1)] <- quantile(l1[ ,n.x1] - l1[ ,1], probs=quantiles)
+    rownames(l2) <- c(paste(c(rep(paste(x1name,"="),n.x1),
+                              paste("\u0394","(",x1vals[1],",",x1vals[length(x1vals)],")")),
+                            c(x1vals,"")))  
+    colnames(l2) <- c("mean",quantiles)
+    
+    ans <- new("post", 
+               est=round(l2, digits=digits), 
+               did=NULL, 
+               sims=l1, 
+               model=class(model), 
+               link=family(model)[2], 
+               quantiles=quantiles, 
+               call=call)
+    return(ans)
+  } 
+  
+  else{
+    
+    n.x1 <- length(x1vals)
+    n.x2 <- length(x2vals)
+    X <- array(NA, c(n.obs,k,n.x1,n.x2))
+    
+    for (j in 1:n.x2){
+      for (i in 1:n.x1){
+        newdata <- data.frame(model$model)
+        if (!is.null(holds)){
+          for (k in 1:length(holds)){
+            newdata[ ,names(holds)[k]] <- as.numeric(holds[k])
+          }
+        }
+        newdata[ ,x1name] <- x1vals[i]
+        newdata[ ,x2name] <- x2vals[j]
+        X[ , ,i,j] <- model.matrix(lm(formula(model), data=newdata))
+      }
+    }
+    
+    X <- aperm(X, c(2,1,3,4))
+    l1 <- apply(apply(X, c(2,3,4), function(x) link(sims@coef %*% x)), c(1,3,4), function(x) weighted.mean(x, wi))
+    l2 <- array(NA, c(n.x1+1,n.q+1,n.x2))
+    l2[1:n.x1,1,1:n.x2] <- apply(l1,c(2,3),mean)
+    l2[1:n.x1,2:(n.q+1),1:n.x2] <- aperm(apply(l1, c(2,3), function(x) quantile(x, probs=quantiles)), c(2,1,3))
+    l2[nrow(l2),1,1:n.x2] <- apply(l1[ ,n.x1,1:n.x2] - l1[ ,1,1:n.x2], 2, mean)
+    l2[nrow(l2),2:(n.q+1),1:n.x2] <- apply(l1[ ,n.x1,1:n.x2] - l1[ ,1,1:n.x2], 2, function(x) quantile(x, probs=quantiles))
+    dimnames(l2) <- list(paste(c(rep(paste(x1name,"="),n.x1),paste("\u0394","(",x1vals[1],",",x1vals[length(x1vals)],")")),c(x1vals,"")),
+                         c("mean",quantiles),
+                         paste(c(rep(paste(x2name,"="),n.x2)),
+                               c(x2vals)))
+    
+    if (is.null(did)){did <- c(x2vals[1],x2vals[n.x2])} else{did <- did}
+    l3 <- array(NA, c(1,n.q+1))
+    l3[1,1] <- mean((l1[ ,n.x1,match(did[2],x2vals)] - l1[ ,1,match(did[2],x2vals)]) -  (l1[ ,n.x1,match(did[1],x2vals)] - l1[ ,1,match(did[1],x2vals)]))
+    l3[1,2:(n.q+1)] <- quantile((l1[ ,n.x1,match(did[2],x2vals)] - l1[ ,1,match(did[2],x2vals)]) -  (l1[ ,n.x1,match(did[1],x2vals)] - l1[ ,1,match(did[1],x2vals)]), probs=quantiles)
+    dimnames(l3) <- list("did",c("mean",quantiles)) 
+    
+    ans <- new("post", 
+               est=round(l2, digits=digits), 
+               did=round(l3, digits=digits), 
+               sims=l1, 
+               model=class(model), 
+               link=family(model)[2], 
+               quantiles=quantiles, 
+               call=call)
+    return(ans)
+  }
+}
+
+
+post.polr <- function(model,x1name=NULL,x1vals=NULL,x2name=NULL,x2vals=NULL,holds=NULL,
+         n.sims=1000,cut=NULL,quantiles=c(.025,.975),did=NULL,weights=NULL, digits=2){
+  
+  call <- match.call()
+  
+  sims <- suppressMessages(postSim(model, n.sims=n.sims))
+  
+  if (is.null(weights)){wi <- c(rep(1, length(model$model[,1])))} else{wi <- weights}
+  
+  if (model$method=="probit"){link <- pnorm}
+  else if (model$method=="logistic"){link <- plogis}
+  else if (model$method=="cloglog"){link <- function(x){1-exp(-exp(x))}}
+  else {stop("Link function is not supported")}
+  
+  n.obs <- length(model$model[,1])
+  k <- length(model.matrix(polr(getCall(model)$formula, model$model))[1,])
+  n.q <- length(quantiles)
+  n.y <- length(levels(model$model[,1]))
+  n.z <- length(model$zeta)
+  tau <- array(NA, c(n.sims,n.z+2))
+  tau[,1] <- -Inf
+  tau[,2:(ncol(tau)-1)] <- sims@zeta[,1:n.z]
+  tau[,ncol(tau)] <- Inf
+  beta <- sims@coef
+  
+  if (is.null(cut)){
+    
+    if (is.null(x1name)){
+      
+      X_temp <- array(NA, c(n.obs,k))
+      X <- array(NA, c(n.obs,k-1))
+      
+      newdata <- data.frame(model$model)
+      if (!is.null(holds)){
+        for (j in 1:length(holds)){
+          newdata[ ,names(holds)[j]] <- as.numeric(holds[j])
+        }
+      }
+      X_temp[ , ] <- suppressWarnings(model.matrix(polr(getCall(model)$formula, data=newdata)))
+      X[ , ] <- X_temp[,-1]
+      X <- aperm(X)
+      
+      l1 <- array(NA, c(n.sims, n.obs, n.y))
+      for (z in 1:n.y){
+        l1[,,z] <- link(tau[,z+1] - beta %*% X) - link(tau[,z] - beta %*% X)
+      }
+      
+      l2 <- apply(l1, c(1,3), function(x) weighted.mean(x, wi))
+      l3 <- array(NA, c(n.y,n.q+1))
+      for (i in 1:n.y){
+        l3[i,1] <- mean(l2[,i])
+        l3[i,2:(n.q+1)] <- quantile(l2[,i], probs=quantiles)
+      }
+      rownames(l3) <- paste(c(rep("Y =",n.y)), c(1:n.y))
+      colnames(l3) <- c("mean",quantiles)
+      
+      ans <- new("post", 
+                 est=round(l3, digits=digits), 
+                 did=NULL, 
+                 sims=l2, 
+                 model=class(model), 
+                 link=model$method, 
+                 quantiles=quantiles, 
+                 call=call)
+      return(ans)
+    }
+    
+    else if (is.null(x2name)){
+      
+      n.x1 <- length(x1vals)
+      
+      X_temp <- array(NA, c(n.obs,k,n.x1))
+      X <- array(NA, c(n.obs,k-1,n.x1))
+      
+      for (i in 1:(n.x1)){
+        newdata <- data.frame(model$model)
+        if (!is.null(holds)){
+          for (j in 1:length(holds)){
+            newdata[ ,names(holds)[j]] <- as.numeric(holds[j])
+          }
+        }
+        newdata[ ,x1name] <- x1vals[i]
+        X_temp[ , ,i] <- suppressWarnings(model.matrix(polr(getCall(model)$formula, data=newdata)))
+        X[ , ,i] <- X_temp[,-1,i]
+      }
+      
+      l1 <- array(NA, c(n.sims, n.obs, n.x1, n.y))
+      X <- aperm(X, c(2,1,3))
+      for (z in 1:n.y){
+        l1[,,,z] <- apply(X, c(2,3), function(x) (link(tau[,z+1] - beta %*% x) - link(tau[,z] - beta %*% x)))
+      }
+      
+      l2 <- apply(l1, c(1,3,4), function(x) weighted.mean(x, wi))
+      l3 <- array(NA, c(n.x1+1, n.q+1, n.y))
+      for (j in 1:n.y){
+        for (i in 1:n.x1){
+          l3[i,1,j] <- mean(l2[,i,j])
+          l3[i,2:(n.q+1),j] <- quantile(l2[,i,j], probs=quantiles)
+        }
+        l3[nrow(l3),1,j] <- mean(l2[ ,n.x1,j] - l2[ ,1,j])
+        l3[nrow(l3),2:(n.q+1),j] <- quantile(l2[ ,n.x1,j] - l2[ ,1,j], probs=quantiles)
+      }
+      dimnames(l3) <- list(paste(c(rep(paste(x1name,"="),n.x1),paste("\u0394","(",x1vals[1],",",x1vals[length(x1vals)],")")),c(x1vals,"")),
+                           c("mean",quantiles),
+                           paste(c(rep("Y =",length(levels(model$model[,1])))),
+                                 c(1:length(levels(model$model[,1]))))) 
+      
+      ans <- new("post", 
+                 est=round(l3, digits=digits), 
+                 did=NULL, 
+                 sims=l2, 
+                 model=class(model), 
+                 link=model$method, 
+                 quantiles=quantiles, 
+                 call=call)
+      return(ans)
+    }
+    
+    else{
+      
+      n.x1 <- length(x1vals)
+      n.x2 <- length(x2vals)
+      
+      X_temp <- array(NA, c(n.obs,k,n.x1,n.x2))
+      X <- array(NA, c(n.obs,k-1,n.x1,n.x2))
+      
+      for (j in 1:n.x2){
+        for (i in 1:(n.x1)){
+          newdata <- data.frame(model$model)
+          if (!is.null(holds)){
+            for (k in 1:length(holds)){
+              newdata[ ,names(holds)[k]] <- as.numeric(holds[k])
+            }
+          }
+          newdata[ ,x1name] <- x1vals[i]
+          newdata[ ,x2name] <- x2vals[j]
+          X_temp[ , ,i,j] <- suppressWarnings(model.matrix(polr(getCall(model)$formula, data=newdata)))
+          X[ , ,i,j] <- X_temp[,-1,i,j]
+        }
+      }
+      
+      X <- aperm(X, c(2,1,3,4))
+      
+      l1 <- array(NA, c(n.sims, n.obs, n.x1, n.x2, n.y))
+      for (z in 1:n.y){
+        l1[,,,,z] <- apply(X, c(2,3,4), function(x) (link(tau[,z+1] - beta %*% x) - link(tau[,z] - beta %*% x)))
+      }
+      
+      l2 <- apply(l1, c(1,3,4,5), function(x) weighted.mean(x, wi))
+      l3 <- array(NA, c(n.x1+1, n.q+1, n.x2, n.y))
+      for (k in 1:n.y){
+        for (j in 1:n.x2){
+          for (i in 1:n.x1){
+            l3[i,1,j,k] <- mean(l2[,i,j,k])
+            l3[i,2:(n.q+1),j,k] <- quantile(l2[,i,j,k], probs=quantiles)
+          }
+          l3[n.x1+1,1,j,k] <- mean(l2[,n.x1,j,k] - l2[,1,j,k])
+          l3[n.x1+1,2:(n.q+1),j,k] <- quantile(l2[,n.x1,j,k] - l2[,1,j,k], probs=quantiles)
+        }
+      }
+      dimnames(l3) <- list(paste(c(rep(paste(x1name," ="),n.x1),paste("\u0394","(",x1vals[1],",",x1vals[length(x1vals)],")")),c(x1vals,"")),
+                           c("mean",quantiles),
+                           paste(c(rep(paste(x2name,"="),n.x2)),x2vals),
+                           paste(c(rep("Y =",n.y)), c(1:n.y))) 
+      
+      if (is.null(did)){did <- c(x2vals[1],x2vals[n.x2])} else{did <- did}
+      l4 <- array(NA, c(n.y,n.q+1))
+      for (i in 1:n.y){
+        l4[i,1] <- mean((l2[ ,n.x1,match(did[2],x2vals),i] - l2[ ,1,match(did[2],x2vals),i]) -  (l2[ ,n.x1,match(did[1],x2vals),i] - l2[ ,1,match(did[1],x2vals),i]))
+        l4[i,2:(n.q+1)] <- quantile((l2[ ,n.x1,match(did[2],x2vals),i] - l2[ ,1,match(did[2],x2vals),i]) -  (l2[ ,n.x1,match(did[1],x2vals),i] - l2[ ,1,match(did[1],x2vals),i]), probs=quantiles)
+      }
+      yvals <- 1:n.y
+      dimnames(l4) <- list(paste(c(rep(paste("Y","="),n.y)),yvals),c("mean",quantiles)) 
+      
+      ans <- new("post", 
+                 est=round(l3, digits=digits), 
+                 did=round(l4, digits=digits), 
+                 sims=l2, 
+                 model=class(model), 
+                 link=model$method, 
+                 quantiles=quantiles, 
+                 call=call)
+      return(ans)
+    }
+  }
+  
+  else{
+    
+    if (is.null(x1name)){
+      
+      X_temp <- array(NA, c(n.obs,k))
+      X <- array(NA, c(n.obs,k-1))
+      
+      newdata <- data.frame(model$model)
+      if (!is.null(holds)){
+        for (j in 1:length(holds)){
+          newdata[ ,names(holds)[j]] <- as.numeric(holds[j])
+        }
+      }
+      X_temp[ , ] <- suppressWarnings(model.matrix(polr(getCall(model)$formula, data=newdata)))
+      X[ , ] <- X_temp[,-1]
+      X <- aperm(X)
+      
+      l1 <- apply(link(-tau[,cut+1] + beta %*% X), 1, function(x) weighted.mean(x, wi))
+      l2 <- array(NA, c(1,n.q+1))
+      l2[1,1] <- mean(l1)
+      l2[1,2:(n.q+1)] <- quantile(l1, probs=quantiles)
+      colnames(l2) <- c("mean",quantiles)
+      
+      ans <- new("post", 
+                 est=round(l2, digits=digits), 
+                 did=NULL, 
+                 sims=l1, 
+                 model=class(model), 
+                 link=model$method, 
+                 quantiles=quantiles, 
+                 call=call)
+      return(ans)
+    }
+    
+    
+    else if (is.null(x2name)){
+      
+      n.x1 <- length(x1vals)
+      
+      X_temp <- array(NA, c(n.obs,k,n.x1))
+      X <- array(NA, c(n.obs,k-1,n.x1))
+      
+      for (i in 1:(n.x1)){
+        newdata <- data.frame(model$model)
+        if (!is.null(holds)){
+          for (j in 1:length(holds)){
+            newdata[ ,names(holds)[j]] <- as.numeric(holds[j])
+          }
+        }
+        newdata[ ,x1name] <- x1vals[i]
+        X_temp[ , ,i] <- suppressWarnings(model.matrix(polr(getCall(model)$formula, data=newdata)))
+        X[ , ,i] <- X_temp[,-1,i]
+      }
+      
+      X <- aperm(X, c(2,1,3))
+      l1 <- apply(apply(X, c(2,3), function(x) link(-tau[,cut+1] + beta %*% x)), 
+                  c(1,3), function(x) weighted.mean(x, wi))
+      l2 <- array(NA, c(n.x1+1,n.q+1))
+      for (i in 1:n.x1){
+        l2[i,1] <- mean(l1[,i])
+        l2[i,2:(n.q+1)] <- quantile(l1[,i], probs=quantiles)
+      }
+      l2[nrow(l2),1] <- mean(l1[ ,ncol(l1)] - l1[ ,1])
+      l2[nrow(l2),2:(n.q+1)] <- quantile(l1[ ,ncol(l1)] - l1[ ,1], probs=quantiles)
+      rownames(l2) <- c(paste(c(rep(paste(x1name,"="),n.x1),
+                                paste("\u0394","(",x1vals[1],",",x1vals[length(x1vals)],")")),
+                              c(x1vals,"")))  
+      colnames(l2) <- c("mean",quantiles)
+      
+      ans <- new("post", 
+                 est=round(l2, digits=digits), 
+                 did=NULL, 
+                 sims=l1, 
+                 model=class(model), 
+                 link=model$method, 
+                 quantiles=quantiles, 
+                 call=call)
+      return(ans)
+    } 
+    
+    else{
+      
+      n.x1 <- length(x1vals)
+      n.x2 <- length(x2vals)
+      
+      X_temp <- array(NA, c(n.obs,k,n.x1,n.x2))
+      X <- array(NA, c(n.obs,k-1,n.x1,n.x2))
+      
+      for (j in 1:n.x2){
+        for (i in 1:n.x1){
+          newdata <- data.frame(model$model)
+          if (!is.null(holds)){
+            for (k in 1:length(holds)){
+              newdata[ ,names(holds)[k]] <- as.numeric(holds[k])
+            }
+          }
+          newdata[ ,x1name] <- x1vals[i]
+          newdata[ ,x2name] <- x2vals[j]
+          X_temp[ , ,i,j] <- suppressWarnings(model.matrix(polr(getCall(model)$formula, data=newdata)))
+          X[ , ,i,j] <- X_temp[,-1,i,j]
+        }
+      }
+      
+      X <- aperm(X, c(2,1,3,4))
+      l1 <- apply(apply(X, c(2,3,4), function(x) link(-tau[,cut+1] + beta %*% x)), c(1,3,4), function(x) weighted.mean(x, wi))
+      l2 <- array(NA, c(n.x1+1,n.q+1,n.x2))
+      for (j in 1:n.x2){
+        for (i in 1:n.x1){
+          l2[i,1,j] <- mean(l1[,i,j])
+          l2[i,2:(n.q+1),j] <- quantile(l1[,i,j], probs=quantiles)
+        }
+        l2[nrow(l2),1,j] <- mean(l1[ ,n.x1,j] - l1[ ,1,j])
+        l2[nrow(l2),2:(n.q+1),j] <- quantile(l1[ ,n.x1,j] - l1[ ,1,j], probs=quantiles)
+      }
+      dimnames(l2) <- list(paste(c(rep(paste(x1name," ="),n.x1),paste("\u0394","(",x1vals[1],",",x1vals[length(x1vals)],")")),c(x1vals,"")),
+                           c("mean",quantiles),
+                           paste(c(rep(paste(x2name," ="),n.x2)),
+                                 c(x2vals)))
+      
+      if (is.null(did)){did <- c(x2vals[1],x2vals[n.x2])} else{did <- did}
+      l3 <- array(NA, c(1,n.q+1))
+      l3[1,1] <- mean((l1[ ,n.x1,match(did[2],x2vals)] - l1[ ,1,match(did[2],x2vals)]) -  (l1[ ,n.x1,match(did[1],x2vals)] - l1[ ,1,match(did[1],x2vals)]))
+      l3[1,2:(n.q+1)] <- quantile((l1[ ,n.x1,match(did[2],x2vals)] - l1[ ,1,match(did[2],x2vals)]) -  (l1[ ,n.x1,match(did[1],x2vals)] - l1[ ,1,match(did[1],x2vals)]), probs=quantiles)
+      dimnames(l3) <- list("did",c("mean",quantiles)) 
+      
+      ans <- new("post", 
+                 est=round(l2, digits=digits), 
+                 did=round(l3, digits=digits), 
+                 sims=l1, 
+                 model=class(model), 
+                 link=model$method, 
+                 quantiles=quantiles, 
+                 call=call)
+      return(ans)
+    }
+  }
+}
+
+setMethod("post", signature(model = "lm"), post.glm)
+setMethod("post", signature(model = "glm"), post.glm)
+setMethod("post", signature(model = "svyglm"), post.glm)  
+setMethod("post", signature(model = "polr"), post.polr)  
+
+    
+
+
+

36/replication_package/postSim.R

@@ -0,0 +1,173 @@
+###### postSim ######
+
+setGeneric("postSim", 
+           function(object, n.sims=1000){
+             standardGeneric("postSim")
+           }
+)
+
+setClass("postSim", 
+         slots = c(coef = "matrix",
+                   sigma = "numeric")
+)
+
+setClass("postSim.polr", 
+         slots = c(coef = "matrix",
+                   zeta = "matrix")
+)
+
+setMethod("postSim", signature(object = "lm"),
+          function(object, n.sims=1000)
+          {
+            object.class <- class(object)[[1]]
+            summ <- summary (object)
+            coef <- summ$coef[,1:2,drop=FALSE]
+            dimnames(coef)[[2]] <- c("coef.est","coef.sd")
+            sigma.hat <- summ$sigma
+            beta.hat <- coef[,1,drop = FALSE]
+            V.beta <- summ$cov.unscaled
+            n <- summ$df[1] + summ$df[2]
+            k <- summ$df[1]
+            sigma <- rep (NA, n.sims)
+            beta <- array (NA, c(n.sims,k))
+            dimnames(beta) <- list (NULL, rownames(beta.hat))
+            for (s in 1:n.sims){
+              sigma[s] <- sigma.hat*sqrt((n-k)/rchisq(1,n-k))
+              beta[s,] <- MASS::mvrnorm (1, beta.hat, V.beta*sigma[s]^2)
+            }
+            
+            ans <- new("postSim",
+                       coef = beta,
+                       sigma = sigma)
+            return (ans)
+          }
+)
+
+
+setMethod("postSim", signature(object = "glm"),
+          function(object, n.sims=1000)
+          {
+            object.class <- class(object)[[1]]
+            summ <- summary (object, correlation=TRUE, dispersion = object$dispersion)
+            coef <- summ$coef[,1:2,drop=FALSE]
+            dimnames(coef)[[2]] <- c("coef.est","coef.sd")
+            beta.hat <- coef[,1,drop=FALSE]
+            sd.beta <- coef[,2,drop=FALSE]
+            corr.beta <- summ$corr
+            n <- summ$df[1] + summ$df[2]
+            k <- summ$df[1]
+            V.beta <- corr.beta * array(sd.beta,c(k,k)) * t(array(sd.beta,c(k,k)))
+            beta <- array (NA, c(n.sims,k))
+            dimnames(beta) <- list (NULL, dimnames(beta.hat)[[1]])
+            for (s in 1:n.sims){
+              beta[s,] <- MASS::mvrnorm (1, beta.hat, V.beta)
+            }
+            # Added by Masanao
+            beta2 <- array (0, c(n.sims,length(coefficients(object))))
+            dimnames(beta2) <- list (NULL, names(coefficients(object)))
+            beta2[,dimnames(beta2)[[2]]%in%dimnames(beta)[[2]]] <- beta
+            # Added by Masanao
+            sigma <- rep (sqrt(summ$dispersion), n.sims)
+            
+            ans <- new("postSim",
+                       coef = beta2,
+                       sigma = sigma)
+            return(ans)
+          }
+)
+
+
+setMethod("postSim", signature(object = "polr"),
+          function(object, n.sims=1000){
+            x <- as.matrix(model.matrix(object))
+            coefs <- coef(object)
+            k <- length(coefs)
+            zeta <- object$zeta
+            Sigma <- vcov(object)
+            
+            if(n.sims==1){
+              parameters <- t(MASS::mvrnorm(n.sims, c(coefs, zeta), Sigma))
+            }else{
+              parameters <- MASS::mvrnorm(n.sims, c(coefs, zeta), Sigma)
+            }
+            ans <- new("postSim.polr",
+                       coef = parameters[,1:k,drop=FALSE],
+                       zeta = parameters[,-(1:k),drop=FALSE])
+            return(ans)
+          }
+)
+
+
+setMethod("postSim", signature(object = "svyglm"),
+          function(object, n.sims=1000)
+          {
+            object.class <- class(object)[[2]]
+            summ <- summary (object, correlation=TRUE, dispersion = object$dispersion)
+            coef <- summ$coef[,1:2,drop=FALSE]
+            dimnames(coef)[[2]] <- c("coef.est","coef.sd")
+            beta.hat <- coef[,1,drop=FALSE]
+            sd.beta <- coef[,2,drop=FALSE]
+            corr.beta <- summ$corr
+            n <- summ$df[1] + summ$df[2]
+            k <- summ$df[1]
+            V.beta <- corr.beta * array(sd.beta,c(k,k)) * t(array(sd.beta,c(k,k)))
+            beta <- array (NA, c(n.sims,k))
+            dimnames(beta) <- list (NULL, dimnames(beta.hat)[[1]])
+            for (s in 1:n.sims){
+              beta[s,] <- MASS::mvrnorm (1, beta.hat, V.beta)
+            }
+            beta2 <- array (0, c(n.sims,length(coefficients(object))))
+            dimnames(beta2) <- list (NULL, names(coefficients(object)))
+            beta2[,dimnames(beta2)[[2]]%in%dimnames(beta)[[2]]] <- beta
+            sigma <- rep (sqrt(summ$dispersion), n.sims)
+            
+            ans <- new("postSim",
+                       coef = beta2,
+                       sigma = sigma)
+            return(ans)
+          }
+)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

36/should_reproduce.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5e35976e408ddac58129b747106217d47cd00a01cac05276e73bdb6794b4c0c
+size 46