.packageName <- "metaArray"
"Zscore" <-
function(merged, pheno=NULL, permute=0, verbose=TRUE) {     
  l <- length(merged)
  inter <- intersection(merged)
  common.gname <- rownames(exprs(inter))
  expr <- cl <- NULL
  if(is.null(pheno)) {
    cat("Pheno data is assumed to be in the first column of phenoData slot\n")
    pheno <- rep(1,l)
  }
  for(i in 1:l) {
    expr[[i]] <- exprs(merged[i])[match(common.gname,rownames(exprs(merged[i]))),]
    cl[[i]] <- pData(merged[i])[,pheno[i]]
  }

  # Logistics: number of samples, class label
  n <- length(expr)
  for(i in 1:n) {
    if(length(unique(cl[[i]]))!=2) {
      cat("Error in labels from data", i, "\n") 
      stop("Class label allows only two unique elements\n")
    }
  }
  mu0 <- mu1 <- sigma0 <- sigma1 <- NULL
  lab <- unique(cl[[1]]); lab <- lab[order(lab)]
  cat(lab[1], "marked as 0\n")
  cat(lab[2], "marked as 1\n")
  cat("Contrast will be", lab[2], "-", lab[1], "\n")
  for(i in 2:n) {
    tmp <- unique(cl[[i]]); tmp <- tmp[order(tmp)]
    if(sum(lab == tmp)!=2)
      stop("Disparate class labels between datasets\n")
  }

  # Change class labels to 0-1
  for(i in 1:n) {
    cl[[i]][cl[[i]]==lab[1]] <- 0
    cl[[i]][cl[[i]]==lab[2]] <- 1
  }
  
  # calculate mu and sigma's within each class label
  # for all datasets. make a list object for it.
  # Script smoothed mean-variance curve and penalized var estimates

  # Calculate the overall contrast by formula.
  nr <- length(common.gname)
  nc <- rep(0,l)
  for(i in 1:l) nc[i] <- length(cl[[i]])
  
  res <-
    .C("contr",as.double(unlist(expr)),
       as.integer(unlist(cl)),
       as.integer(l),
       as.integer(nr),
       as.integer(nc),
       as.integer(permute),
       z=double(nr),
       p=double(nr),
       PACKAGE="metaArray"
      )
  obj <- as.data.frame(cbind(Zscore=res$z,Pvalue=res$p))
  rownames(obj) <- common.gname
  return(obj)
}

"em.draw" <-
function(vec, cl=NULL, threshold=0.0001) {
  par(mfrow=c(2,2))
  raw <- as.numeric(vec) 
  if(is.null(cl)) cl <- rep(1,length(vec))
  fit.tmp <- fit.em(raw, cl, threshold)
  trans <- fit.tmp$expr
  lik <- fit.tmp$lik.rec
  ord <- order(raw)
  raw <- raw[ord]; trans <- trans[ord]
  plot(raw, trans, main="estimated poe", xlab="raw expression", ylab="probability", ylim=c(-1.1,1.1), pch=3,col=2)
  lines(raw, trans, lty=3, col=2)
  abline(0,0, lty=2, col=4)
  mu <-fit.tmp$mu;sigmasq<-fit.tmp$sigmasq
  pi<-fit.tmp$pi
  a <-fit.tmp$a; b<-fit.tmp$b
  xvals <- seq(a,b,by=0.01)
  deu <- dunif(xvals,a,b)
  den <- dnorm(xvals,mu,sigmasq)
  dem <- pi * deu + (1-pi) * den
  plot(xvals, dem, type="n", main="mixture density", xlab="expression", ylab="density", ylim=c(0, max(c(den,dem,deu))*1.1))
  lines(xvals, dem, lty=2, col=2)
  lines(xvals, deu, lty=3, col=4)
  lines(xvals, den, lty=3, col=4)
  hist(raw, main="raw expression")
  lik.max <- max(lik) 
  lik.min <- min(lik)
  lik.len <- length(lik)
  plot(1:lik.len, lik, xlim=c(0,lik.len+1), ylim=c(lik.min,lik.max), main="log likelihood", xlab="iteration", ylab="likelihood", type="n")
  lines(1:lik.len, lik, lty=1, col=2)
}

"find.init" <-
function(z, width = 1) {
  len <- length(z)
  init <- rep(0,len)
  for(i in 1:len) {
    test.z <- z[i]
    train.z <- z[-i]
    med.z <- median(train.z)
    sigmasq <- sum((train.z-med.z)^2)/(len-1)
    dr <- abs(test.z - med.z)
    dthe <- width * sqrt(sigmasq)
    init[i] <- as.numeric(dr > dthe)  
  }
  return(init)
}

"fit.em" <-
function(x, cl=NULL, threshold=1e-10){ 
  conv <- TRUE
  dec <- FALSE
  abnormal <- FALSE
  x <- as.numeric(x)
  tt <- length(x)
  z <- rep(0,length(x))
  if(is.null(cl)) cl <- rep(0, length(x))
  if(all(cl==0)) id <- find.init(x)
  else id <- cl    
  log.lik <- 1000
  lik.rec <- NULL
  num.iter <- 0
  if(all(id==1) | all(id==0)) {
    conv <- FALSE
    abnormal <- TRUE
    lik.rec <- 0
  }
  if(all(cl==0)) z[id == 1] <- 1
  else z <- rep(0.5,tt)

  a <- min(x,na.rm=TRUE); b <- max(x,na.rm=TRUE)
  #a <- a - (b-a)*.001; b <- b + (b-a)*.001  
  err <- err.old <- 1

  if(all(cl==0)) pi <- sum(z) / tt
  else pi <- sum(cl) / tt

  mu <- sum((1-z)*x) / sum(1-z)
  sigmasq <- sum((1-z)*(x-mu)^2) / sum(1-z)

  while(err > threshold & conv == TRUE) {
    num.iter <- num.iter + 1
    log.lik.old <- log.lik
    err.old <- err
    z.old <- z
   ## E Step
    est.u <- dunif(x,a,b)
    est.u.p <- pi * est.u
    est.n <- dnorm(x,mu,sqrt(sigmasq))
    est.n.p <- (1-pi) * est.n
    z <- est.u.p / (est.n.p + est.u.p)

    if(any(is.na(z))) conv <- FALSE
   ## M Step
    if(any(cl==1)) z[cl==0] <- 0
    pi <- sum(z) / tt
    if(any(cl==1)) pi <- max(pi, 1 / tt)
    #if(any(cl==1)) pi <- sum(z) / sum(cl)
    mu <- sum((1-z)*x) / sum(1-z)
    sigmasq <- sum((1-z)*((x-mu)^2)) / sum(1-z)

    sgn.z <- ifelse(x < mu, -1, 1)  
    #est.u[est.u==0] <- 1e-15 
    #est.n[est.n==0] <- 1e-15

    est.u <- dunif(x,a,b)
    est.u.p <- pi * est.u
    est.n <- dnorm(x,mu,sqrt(sigmasq))
    est.n.p <- (1-pi) * est.n
    
    log.lik <- sum(log(est.u.p + est.n.p))
    err <- abs(log.lik.old - log.lik)
    if(num.iter != 1) lik.rec[num.iter-1] <- log.lik
    dec <- ifelse(log.lik.old > log.lik, TRUE, FALSE)
    if(any(pi==0 | pi==1)) err <- 0
  }

  if(any(cl==1)) pi <- max(1/tt,pi)
  est.u.p <- pi * dunif(x,a,b) 
  est.n.p <- (1-pi) * dnorm(x,mu,sqrt(sigmasq))
  est.u.mu <- pi * dunif(mu,a,b)
  est.n.mu <- (1-pi) * dnorm(mu,mu,sqrt(sigmasq))
  z0 <- est.u.p / (est.n.p + est.u.p)
  zmu <- est.u.mu / (est.n.mu + est.u.mu)
  sgn.z0 <- ifelse(x < mu, -1, 1) 
  loc <- (max(lik.rec) != lik.rec[length(lik.rec)])
  if(!conv | abnormal) {
    expr <- rep(NA,tt)
    mu <- sigmasq <- pi <- NA
    loc <- FALSE
    lik.rec <- 0
  }
  else {
    expr <- rep(NA, tt)
    expr <- (z0-zmu) * sgn.z0
  }
  return(list(expr=expr, a=a, b=b, sigmasq=sigmasq, mu=mu, pi=pi, conv=conv, dec=dec, loc=loc, lik.rec=lik.rec, abnormal=abnormal))
}

require(MergeMaid)

intcor <- function(merged) {     
  l <- length(merged)
  if(l<=1) stop("More than a single study is required to run integrative correlation\n")
  inter <- intersection(merged)
  common.gname <- rownames(exprs(inter))
  expr <- cl <- NULL
  for(i in 1:l) {
    expr[[i]] <- exprs(merged[i])[match(common.gname,rownames(exprs(merged[i]))),]
    cl[[i]] <- rep(0,dim(expr[[i]])[2])
  }
  nr <- length(common.gname)
  nc <- rep(0,l)
  for(i in 1:l) nc[i] <- length(cl[[i]])
  
  res <-
    .C("intcor",as.double(unlist(expr)),
       as.integer(unlist(cl)),
       as.integer(l),
       as.integer(nr),
       as.integer(nc),
       correl=double(nr),
       paircor=double((l*(l-1)/2)*nr),
       PACKAGE="metaArray"
      )
  tmp.paircor <- matrix(res$paircor, nrow=nr)
  rownames(tmp.paircor) <- common.gname
  obj <- list(pair.cor=tmp.paircor, avg.cor=res$correl)
  return(obj)
}



  
"logit" <-
function(p) log(p)-log(1-p)

"poe.em" <-
function(mat, cl=NULL, threshold=0.00001, every=100) {
  mat <- as.matrix(mat)
  nc <- ncol(mat)
  nr <- nrow(mat)
  if(is.null(cl)) cl <- rep(1,dim(mat)[2])
  cat("Number of Samples:", nc, "\n")
  cat("Number of Genes:", nr, "\n")
  cat("This model assumes that the samples are centered and scaled.\n")
  new.mat <- matrix(0,nr,nc)
  conv <- dec <- loc <- abnormal <- rep(FALSE,nr)
  med.expr <- apply(mat,1,median,na.rm=TRUE)
  new.mat <- sweep(mat,1,med.expr)
  for(i in 1:nr) {
    if(sum(is.na(as.numeric(mat[i,]))) > .25 * nc ) stop("More than 25% missing values for gene", i, "\n")
    zvec <- fit.em(as.numeric(mat[i,]), cl, threshold=threshold) 
    new.mat[i,] <- zvec$expr
    conv[i] <- zvec$conv  
    dec[i] <- zvec$dec
    loc[i] <- zvec$loc
    abnormal[i] <- zvec$abnormal
    if(i%%every==0) cat(i, "genes fitted\n")   
  }
  checkid <- (1:nr)[abnormal]
  len.id <- length(checkid)
  rownames(new.mat) <- rownames(mat)
  colnames(new.mat) <- colnames(mat)
  #cat("The algorithm has shown evidences of\n")
  #cat("local maxima for", sum(loc), "genes\n")
  #cat("decreasing log-likelihood", sum(dec), "genes\n")
  if(len.id!=0) {
    cat("EM failed to find starting points for:\n")
    for(i in 1:len.id) cat(checkid[i], rownames(mat)[i], "\n")
  }
  return(list(data=new.mat, conv=conv, dec=dec, loc=loc))
}

"poe.mcmc" <-
function (AA, NN = NULL, id = NULL, M = 2000, kap.min=3.0,
    logdata=FALSE,     stepsize = 0.5, 
    centersample = TRUE, centergene = TRUE, generatestarts = TRUE, start.method = 1, 
    startobject = R0, collapse.to.two = TRUE,
    collapse.window=50,converge.threshold=0.01, burnin=500,
    PR = list(alpha.mm = 0, alpha.sd = 100, mu.mm = 0, mu.sd = 100, 
        pipos.mm = 0, pipos.sd = 100, pineg.mm = 0, pineg.sd = 100, 
        kap.pri.rate = 1, tausqinv.aa = 1, tausqinv.bb = 0.1)) 
{
    TT <- ncol(AA)
    GG <- nrow(AA)
    tmp.poemat <- matrix(0,GG,TT)
    if (!is.null(NN) & length(NN) != TT) {
        stop("Length of NN should be the same as ncol(AA)")
    }
    if(is.na(sum(as.vector(AA))))
      stop("NA values not allowed in AA matrix. Remove rows with NA values and retry.")
    if (logdata == TRUE) 
        AA <- log(AA)
    if (is.null(id) == TRUE) 
        id <- as.character(1:GG)
    if (is.null(NN) == TRUE) 
        NN <- rep(0, TT)
    if (centersample) {
        sammed <- apply(AA, 2, median)
        AA <- sweep(AA, 2, sammed)
    }
    if (centergene) {
        genmed <- apply(AA, 1, median)
        AA <- sweep(AA, 1, genmed)
    }
    if (generatestarts == TRUE) {
        alpha0 <- apply(AA, 2, mean)
        mats <- t(apply(AA, 1, sort))
        mug0 <- sigmag0 <- kappaposg0 <- kappanegg0 <- rep(NA, 
            GG)
        piposg0 <- pinegg0 <- rep(NA, GG)
        if (start.method == 1) {
            for (gg in 1:GG) {
                mug0[gg] <- mean(mats[gg, -c(1, 2, TT - 1, TT)])
                pinegg0[gg] <- piposg0[gg] <- 2/TT
                sigmag0[gg] <- sqrt(var(mats[gg, -c(1, 2, TT - 
                  1, TT)]))
                kappaposg0[gg] <- max(kap.min * sigmag0[gg], 
                  mug0[gg] - mats[gg, 1])
                kappanegg0[gg] <- max(kap.min * sigmag0[gg], 
                  mats[gg, TT] - mug0[gg])
            }
        }
        if (start.method == 2) {
            for (gg in 1:GG) {
                clu <- kmeans(mats[gg, ], 2)
                if (clu$size[1] == clu$size[2]) {
                  big <- 1
                  sma <- 2
                }
                else {
                  big <- (1:2)[clu$size == max(clu$size)]
                  sma <- (1:2)[clu$size == min(clu$size)]
                }
                mug0[gg] <- clu$centers[big]
                sigmag0[gg] <- sqrt(var(mats[gg, clu$cluster == 
                  big]))
                if (mug0[gg] > 0) {
                  pinegg0[gg] <- clu$size[sma]/TT
                  piposg0[gg] <- 1/TT
                }
                else {
                  piposg0[gg] <- clu$size[sma]/TT
                  pinegg0[gg] <- 1/TT
                }
                kappaposg0[gg] <- max(max(mats[gg, ]) - mug0[gg], 
                  kap.min * sigmag0[gg])
                kappanegg0[gg] <- max(mug0[gg] - min(mats[gg, 
                  ]), kap.min * sigmag0[gg])
            }
        }
        if (start.method == 3) {
            for (gg in 1:GG) {
                clu <- kmeans(mats[gg, ], 3)
                posc <- (1:3)[clu$centers == max(clu$centers)]
                negc <- (1:3)[clu$centers == min(clu$centers)]
                midc <- (1:3)[clu$centers == median(clu$centers)]
                mug0[gg] <- clu$centers[midc]
                sigmag0[gg] <- sqrt(var(mats[gg, clu$cluster == 
                  midc]))
                pinegg0[gg] <- clu$size[negc]/TT
                piposg0[gg] <- clu$size[posc]/TT
                kappaposg0[gg] <- max(max(mats[gg, ]) - mug0[gg], 
                  kap.min * sigmag0[gg])
                kappanegg0[gg] <- max(mug0[gg] - min(mats[gg, 
                  ]), kap.min * sigmag0[gg])
            }
        }
        if (start.method == 4) {
            if (sum(NN) < 3) 
                stop("start.method==4 requires at least 3 normal samples")
            for (gg in 1:GG) {
                mug0[gg] <- mean(AA[gg, NN == 1])
                sigmag0[gg] <- sqrt(var(AA[gg, NN == 1]))
                clu <- kmeans(AA[gg, ], 2)
                norm <- (1:2)[abs(clu$centers - mug0[gg]) == 
                  min(abs(clu$centers - mug0[gg]))]
                expr <- 1
                if (norm == 1) 
                  expr <- 2
                if (clu$centers[norm] > clu$centers[expr]) {
                  pinegg0[gg] <- min(clu$size[expr]/TT, 1/2)
                  piposg0[gg] <- 1/TT
                }
                else {
                  piposg0[gg] <- min(clu$size[expr]/TT, 1/2)
                  pinegg0[gg] <- 1/TT
                }
                kappaposg0[gg] <- max(max(AA[gg, ]) - mug0[gg], 
                  kap.min * sigmag0[gg])
                kappanegg0[gg] <- max(mug0[gg] - min(AA[gg, ]), 
                  kap.min * sigmag0[gg])
            }
        }
        sigmagsqinv0 <- 1/sigmag0^2
        gamma0 <- (mean(sigmagsqinv0))^2/var(sigmagsqinv0)
        lambda0 <- mean(sigmagsqinv0)/var(sigmagsqinv0)
        tmpmat <- matrix(0,GG,TT)

        PP <- list(alpha = alpha0, mug = mug0, kappaposg = kappaposg0, 
            kappanegg = kappanegg0, sigmag = sigmag0, piposg = piposg0, 
            pinegg = pinegg0, mu = mean(mug0), tausqinv = 1/var(mug0), 
            gamma = gamma0, lambda = lambda0, pil.pos.mean = mean(logit(piposg0)), 
            pil.neg.mean = mean(logit(pinegg0)), pil.pos.prec = mean(piposg0) * 
                (1 - mean(piposg0)), pil.neg.prec = mean(pinegg0) * 
                (1 - mean(pinegg0)), kap.pos.rate = 1/mean(kappaposg0), 
            kap.neg.rate = 1/mean(kappanegg0), poe=tmp.poemat, phat.pos=tmpmat, 
            phat.neg=tmpmat, accept = 0)
    }
    if (generatestarts == FALSE) {
        mmm <- length(startobject$gamma)
        PP <- list(alpha = startobject$alpha[mmm, ], mug = startobject$mug[mmm, 
            ], kappaposg = startobject$kappaposg[mmm, ], kappanegg = startobject$kappanegg[mmm, 
            ], sigmag = startobject$sigmag[mmm, ], piposg = startobject$piposg[mmm, 
            ], pinegg = startobject$pinegg[mmm, ], mu = startobject$mu[mmm], 
            tausqinv = startobject$tausqinv[mmm], gamma = startobject$gamma[mmm], 
            lambda = startobject$lambda[mmm], pil.pos.mean = startobject$pil.pos.mean[mmm], 
            pil.pos.prec = startobject$pil.pos.prec[mmm], pil.neg.mean = startobject$pil.neg.mean[mmm], 
            pil.neg.prec = startobject$pil.neg.prec[mmm], kap.pos.rate = startobject$kap.pos.rate[mmm], 
            kap.neg.rate = startobject$kap.neg.rate[mmm], poe=tmp.poemat, 
            phat.pos=tmpmat, phat.neg=tmpmat, accept = 0)
    }
  if (collapse.to.two) {
    cat("Collapsing to Two: ")
    cw <- collapse.window
    mm <- 0
      pidif <- 1
      pim.pos <- pim.neg <- 100
      while ( pidif>converge.threshold) {
        mm <- mm+1
         new.PR <- unlist(PR)
         new.PP <- unlist(PP)
         avgpos <- rep(0,GG*(3*TT+6)+TT+11)
         res <- .C("poe_fit_2",as.matrix(AA),as.integer(NN),
            as.double(new.PR), as.double(new.PP),
            as.integer(GG), as.integer(TT),as.integer(1),
            avgpos=as.double(avgpos), PACKAGE="metaArray")$avgpos
         PP$alpha <- res[1:TT]
         PP$mug <- res[(TT+1):(TT+GG)]
         PP$kappaposg <- res[(TT+GG+1):(TT+2*GG)]
         PP$kappanegg <- res[(TT+2*GG+1):(TT+3*GG)]
         PP$sigmag <- res[(TT+3*GG+1):(TT+4*GG)]
         PP$piposg <- res[(TT+4*GG+1):(TT+5*GG)]
         PP$pinegg <- res[(TT+5*GG+1):(TT+6*GG)]
         PP$mu <- res[TT+6*GG+1]
         PP$tausqinv <- res[TT+6*GG+2]
         PP$gamma <- res[TT+6*GG+3]
         PP$lambda <- res[TT+6*GG+4]
         PP$pil.pos.mean <- res[TT+6*GG+5]
         PP$pil.neg.mean <- res[TT+6*GG+6]
         PP$pil.pos.prec <- res[TT+6*GG+7]
         PP$pil.neg.prec <- res[TT+6*GG+8]
         PP$kap.pos.rate <- res[TT+6*GG+9]
         PP$kap.neg.rate <- res[TT+6*GG+10]
         PP$poe <- matrix(res[(TT+6*GG+11):(GG*(TT+6)+TT+10)], nrow=GG)
         PP$phat.pos <- matrix(res[(GG*(TT+6)+TT+11):(GG*(2*TT+6)+TT+10)], nrow=GG)
         PP$phat.neg <- matrix(res[(GG*(2*TT+6)+TT+11):(GG*(3*TT+6)+TT+10)], nrow=GG)
         PP$accept <- res[GG*(3*TT+6)+TT+11]
         gc();
         pim.pos <- c(pim.pos, mean(PP$piposg))
         pim.neg <- c(pim.neg, mean(PP$pinegg))
        
        if(mm>(2*cw)) {
          pidif <- 0.5*max(
                  abs(mean(pim.neg[(mm-cw-1  ):(mm   )])-
                      mean(pim.neg[(mm-2*cw-1):(mm-cw)]))/
                     (mean(pim.neg[(mm-cw-1  ):(mm   )])+
                      mean(pim.neg[(mm-2*cw-1):(mm-cw)])),
                  abs(mean(pim.pos[(mm-cw-1  ):(mm   )])-
                      mean(pim.pos[(mm-2*cw-1):(mm-cw)]))/
                     (mean(pim.pos[(mm-cw-1  ):(mm   )])+
                      mean(pim.pos[(mm-2*cw-1):(mm-cw)]))) 
         }
     }
     for (gg in 1:GG) {
           ppplus <- mean(PP$phat.pos[gg, ])
           ppminu <- mean(PP$phat.pos[gg, ]-PP$poe[gg,])
           pp0 <- 1 - ppminu - ppplus
           if (ppplus < 2/TT & abs(ppminu - pp0) < 6/TT) {
               PP$phat.pos[gg, ] <- abs(PP$poe[gg, ])
               PP$poe[gg,] <-abs(PP$poe[gg,])
               ee <- round(PP$poe[gg,])
               PP$mug[gg] <- mean(AA[gg,ee==0],na.rm=TRUE)
               PP$piposg[gg] <- mean(ifelse(ee==1,1,0))
               PP$pinegg[gg] <- mean(ifelse(ee==-1,1,0))
               PP$sigmag[gg] <- sqrt(var(AA[gg,ee==0],na.rm=TRUE))
               PP$kappanegg[gg] <- kap.min*PP$sigmag[gg]
               PP$kappaposg[gg] <- kap.min*PP$sigmag[gg]
          }
     }  
     cat("Finished\n")
  }  
  cat("Gibbs Sampler\n")
  new.PR <- unlist(PR)
  new.PP <- unlist(PP)
  avgpos <- rep(0,GG*(3*TT+6)+TT+11)
  res <- .C("poe_fit",as.matrix(AA),as.integer(NN),
       as.double(new.PR),as.double(new.PP),as.integer(GG),
       as.integer(TT),as.integer(M),as.integer(burnin),
       avgpos=as.double(avgpos), PACKAGE="metaArray")$avgpos
  alpha <- res[1:TT]
  mug <- res[(TT+1):(TT+GG)]
  kappaposg <- res[(TT+GG+1):(TT+2*GG)]
  kappanegg <- res[(TT+2*GG+1):(TT+3*GG)]
  sigmag <- res[(TT+3*GG+1):(TT+4*GG)]
  piposg <- res[(TT+4*GG+1):(TT+5*GG)]
  pinegg <- res[(TT+5*GG+1):(TT+6*GG)]
  mu <- res[TT+6*GG+1]
  tausqinv <- res[TT+6*GG+2]
  gamma <- res[TT+6*GG+3]
  lambda <- res[TT+6*GG+4]
  pil.pos.mean <- res[TT+6*GG+5]
  pil.neg.mean <- res[TT+6*GG+6]
  pil.pos.prec <- res[TT+6*GG+7]
  pil.neg.prec <- res[TT+6*GG+8]
  kap.pos.rate <- res[TT+6*GG+9]
  kap.neg.rate <- res[TT+6*GG+10]
  poe <- matrix(res[(TT+6*GG+11):(GG*(TT+6)+TT+10)], nrow=GG)
  poe <- as.data.frame(poe)
  rownames(poe) <- rownames(AA)
  colnames(poe) <- colnames(AA)
  accept <- res[GG*(3*TT+6)+TT+11]
  gc();
  return(list(alpha = alpha, mug = mug, kappaposg = kappaposg, 
        kappanegg = kappanegg, sigmag = sigmag, piposg = piposg, 
        pinegg = pinegg, mu = mu, tausqinv = tausqinv, gamma = gamma, 
        lambda = lambda, pil.pos.mean = pil.pos.mean, pil.pos.prec = pil.pos.prec, 
        pil.neg.mean = pil.neg.mean, pil.neg.prec = pil.neg.prec, 
        kap.pos.rate = kap.pos.rate, kap.neg.rate = kap.neg.rate,
        poe=poe, accept = accept))
}

.First.lib <- function(libname, pkgname, where) {
    library.dynam("metaArray", pkgname, libname)
}

