@@ -1,5 +1,5 @@

 Package: CoGAPS

-Version: 1.3.0

+Version: 1.3.1

 Date: 2010-07-02

 Title: Coordinated Gene Activity in Pattern Sets 

 Author: Elana J. Fertig

@@ -10,9 +10,9 @@ Description: Coordinated Gene Activity in Pattern Sets (CoGAPS) infers

   inferring activity on gene sets. 

 Maintainer: Elana J. Fertig <ejfertig@jhmi.edu>, Michael F. Ochs <mfo@jhu.edu>

 SystemRequirements: GAPS-JAGS (==1.0.2)

-Depends: R (>= 2.9.0), rjags(>= 2.1.0), R.utils (>= 1.2.4)

+Depends: R (>= 2.9.0), R.utils (>= 1.2.4)

 Imports: graphics, grDevices, methods, stats, utils

 License: GPL (== 2)

-URL: http://www.cancerbiostats.onc.jhmi.edu/cogaps.cfm

+URL: http://www.cancerbiostats.onc.jhmi.edu/CoGAPS.cfm

 biocViews: GeneExpression, Microarray, Bioinformatics 

@@ -2,9 +2,16 @@ export(CoGAPS)

 export(GAPS)

 export(calcCoGAPSStat)

 export(plotGAPS)

+if(tools:::.OStype() == "windows") {

+importFrom(utils, readRegistry, winProgressBar, setWinProgressBar)

+}

+importFrom(utils, txtProgressBar, setTxtProgressBar)

+importFrom(stats, variable.names, sd, update)

 importFrom(graphics, matplot, title)

 importFrom(grDevices, dev.new, dev.off, pdf)

 importFrom(methods, is)

-importFrom(rjags, jags.model, load.module, jags.samples)  

 importFrom(stats, heatmap, runif)

 importFrom(utils, read.table, write.table)

+S3method(coef, jags)

+S3method(update, jags)

+S3method(variable.names, jags)

@@ -1,2 +1,3 @@

-CoGAPS requires GAPS-JAGS available from http://www.cancerbiostats.onc.jhmi.edu/cogaps.cfm.  This c++ package is a redistribution of JAGS version 2.1.0 with a module implementing the GAPS matrix decomposition for microarray data.  GAPS-JAGS takes the place of the original JAGS package required for the successful installation and running of the rjags package. Please see the installation instructions in the users manual.  If you have any questions, please comment Elana Fertig <ejfertig@jhmi.edu> or Michael Ochs <mfo@jhu.edu>.

+CoGAPS requires GAPS-JAGS available from http://www.cancerbiostats.onc.jhmi.edu/cogaps.cfm.  This c++ package is a redistribution of JAGS version 2.1.0 with a module implementing the GAPS matrix decomposition for microarray data.  Please see the installation instructions in the users manual.  If you have any questions, please comment Elana Fertig <ejfertig@jhmi.edu> or Michael Ochs <mfo@jhu.edu>.

+01Sep2011 - Removed dependency on rjags package on CRAN

@@ -5,9 +5,6 @@ RunGAPS <- function(data, unc, numPatterns,

                     SAIter, iter, thin=1) {

-  # load in the matrix decomposition module

-  load.module(c("gaps"))

-

   # get the data needed for MCMC

   matrixDecompData <- GetDataListGAPS(data, unc, numPatterns,

                                       MaxAtomsA, alphaA, lambdaA,

new file mode 100644

@@ -0,0 +1,362 @@

+jags.model <- function(file, data=sys.frame(sys.parent()), inits,

+                       n.chains = 1, n.adapt=1000, nchain)

+{

+

+    if (missing(file)) {

+        stop("Model file name missing")

+    }

+    if (!file.exists(file)) {

+        stop(paste("Model file \"", file, "\" not found", sep=""))

+    }

+    if (!missing(nchain)) {

+        warning("Argument nchain in jags.model is deprecated. Use n.chains.")

+        if (missing(n.chains)) {

+            n.chains = nchain

+        }

+    }

+    

+    p <- .Call("make_console", PACKAGE="CoGAPS") 

+    .Call("check_model", p, file, PACKAGE="CoGAPS")

+

+    varnames <- .Call("get_variable_names", p, PACKAGE="CoGAPS")

+    if (is.environment(data)) {

+        ##Get a list of numeric objects from the supplied environment

+        data <- mget(varnames, envir=data, mode="numeric",

+                     ifnotfound=list(NULL))

+        ##Strip null entries

+        data <- data[!sapply(data, is.null)]

+    }

+    else if (is.list(data)) {

+        v <- names(data)

+        if (is.null(v)) {

+            stop("data must be a named list")

+        }

+        if (any(nchar(v)==0)) {

+            stop("unnamed variables in data list")

+        }

+        if (any(duplicated(v))) {

+            stop("Duplicated names in data list: ",

+                 paste(v[duplicated(v)], collapse=" "))

+        }

+        relevant.variables <- v %in% varnames

+        data <- data[relevant.variables]

+        unused.variables <- setdiff(v, varnames)

+        for (i in seq(along=unused.variables)) {

+            warning("Unused variable \"", unused.variables[i], "\" in data")

+        }

+    }

+    else {

+        stop("data must be a list or environment")

+    }

+    

+    .Call("compile", p, data, as.integer(n.chains), TRUE, PACKAGE="CoGAPS")

+

+### Setting initial values

+

+    if (!missing(inits)) {

+

+        checkParameters <- function(inits) {

+            if(!is.list(inits))

+                return (FALSE)

+

+            inames <- names(inits)

+            if (is.null(inames) || any(nchar(inames) == 0))

+                return (FALSE)

+

+            if (any(duplicated(inames)))

+                return (FALSE)

+            

+            if (any(inames==".RNG.name")) {

+                rngname <- inits[[".RNG.name"]]

+                if (!is.character(rngname) || length(rngname) != 1)

+                    return (FALSE)

+                inits[[".RNG.name"]] <- NULL

+            }

+

+            if (!all(sapply(inits, is.numeric)))

+                return (FALSE)

+            

+            return (TRUE)

+        }

+        

+        setParameters <- function(inits, chain) {

+            if (!is.null(inits[[".RNG.name"]])) {

+                .Call("set_rng_name", p, inits[[".RNG.name"]],

+                      as.integer(chain), PACKAGE="CoGAPS")

+                inits[[".RNG.name"]] <- NULL

+            }

+            .Call("set_parameters", p, inits, as.integer(chain),

+                  PACKAGE="CoGAPS")

+        }

+        

+        init.values <- vector("list", n.chains)

+        

+        if (is.function(inits)) {

+            if (any(names(formals(inits)) == "chain")) {

+                for (i in 1:n.chains) {

+                    init.values[[i]] <- inits(chain=i)

+                }

+            }

+            else {

+                for (i in 1:n.chains) {

+                    init.values[[i]] <- inits()

+                }

+            }

+        }

+        else if (is.list(inits)) {

+

+            if (checkParameters(inits)) {

+                ## Replicate initial values for all chains

+                for (i in 1:n.chains) {

+                    init.values[[i]] <- inits

+                }

+            }

+            else {

+                if (length(inits) != n.chains) {

+                    stop("Length mismatch in inits")

+                }

+                init.values <- inits

+            }

+        }

+            

+        for (i in 1:n.chains) {

+            if (!checkParameters(init.values[[i]])) {

+                stop("Invalid parameters for chain ", i)

+            }

+            setParameters(init.values[[i]], i)

+        }

+    }

+

+    .Call("initialize", p, PACKAGE="CoGAPS")

+

+    model.state <- .Call("get_state", p, PACKAGE="CoGAPS")

+    model.data <- .Call("get_data", p, PACKAGE="CoGAPS")

+    model.code <- readLines(file, warn=FALSE)

+    model <- list("ptr" = function() {p},

+                  "data" = function() {model.data},

+                  "model" = function() {model.code},

+                  "state" = function(internal=FALSE)

+                  {

+                      if(!internal) {

+                          for(i in 1:n.chains) {

+                              model.state[[i]][[".RNG.state"]] <- NULL

+                              model.state[[i]][[".RNG.name"]] <- NULL

+                          }

+                      }

+                      return(model.state)

+                  },

+                  "nchain" = function()

+                  {

+                      .Call("get_nchain", p, PACKAGE="CoGAPS")

+                  },

+                  "iter" = function()

+                  {

+                      .Call("get_iter", p, PACKAGE="CoGAPS")

+                  },

+                  "sync" = function() {

+                      

+                      model.state <<- .Call("get_state", p, PACKAGE="CoGAPS")

+                  },

+                  "recompile" = function() {

+                      ## Clear the console

+                      .Call("clear_console", p, PACKAGE="CoGAPS")

+                      p <<- .Call("make_console", PACKAGE="CoGAPS")

+                      ## Write the model to a temporary file so we can re-read it

+                      mf <- tempfile()

+                      writeLines(model.code, mf)

+                      .Call("check_model", p, mf, PACKAGE="CoGAPS")

+                      unlink(mf)

+                      ## Re-compile

+                      .Call("compile", p, data, n.chains, FALSE, PACKAGE="CoGAPS")

+                      ## Re-initialize

+                      if (!is.null(model.state)) {

+                          if (length(model.state) != n.chains) {

+                              stop("Incorrect number of chains in saved state")

+                          }

+                          for (i in 1:n.chains) {

+                              statei <- model.state[[i]]

+                              rng <- statei[[".RNG.name"]]

+                              if (!is.null(rng)) {

+                                  .Call("set_rng_name", p, rng, i, PACKAGE="CoGAPS")

+                                  statei[[".RNG.name"]] <- NULL

+                              }

+                              .Call("set_parameters", p, statei, i, PACKAGE="CoGAPS")

+                          }

+                          .Call("initialize", p, PACKAGE="CoGAPS")

+                          ## Redo adaptation

+                          adapting <- .Call("is_adapting", p, PACKAGE="CoGAPS")

+                          if(n.adapt > 0 && adapting) {

+                              cat("Adapting\n")

+                              .Call("update", p, n.adapt, PACKAGE="CoGAPS")

+                              if (!.Call("adapt_off", p, PACKAGE="CoGAPS")) {

+                                  warning("Adaptation incomplete");

+                              }

+                          }

+                          model.state <<- .Call("get_state", p, PACKAGE="CoGAPS")

+                      }

+                      invisible(NULL)

+                  })

+    class(model) <- "jags"

+

+    if (n.adapt > 0) {

+        adapt(model, n.adapt)

+    }

+    return(model)

+}

+

+parse.varname <- function(varname) {

+

+  ## Try to parse string of form "a" or "a[n,p:q,r]" where "a" is a

+  ## variable name and n,p,q,r are integers

+

+  v <- try(parse(text=varname, n=1), silent=TRUE)

+  if (!is.expression(v) || length(v) != 1)

+    return(NULL)

+

+  v <- v[[1]]

+  if (is.name(v)) {

+    ##Full node array requested

+    return(list(name=deparse(v)))

+  }

+  else if (is.call(v) && identical(deparse(v[[1]]), "[") && length(v) > 2) {

+    ##Subset requested

+    ndim <- length(v) - 2

+    lower <- upper <- numeric(ndim)

+    if (any(nchar(sapply(v, deparse)) == 0)) {

+      ##We have to catch empty indices here or they will cause trouble

+      ##below

+      return(NULL)

+    }

+    for (i in 1:ndim) {

+      index <- v[[i+2]]

+      if (is.numeric(index)) {

+        ##Single index

+        lower[i] <- upper[i] <- index

+      }

+      else if (is.call(index) && length(index) == 3 &&

+               identical(deparse(index[[1]]), ":") &&

+               is.numeric(index[[2]]) && is.numeric(index[[3]]))

+        {

+          ##Index range

+          lower[i] <- index[[2]]

+          upper[i] <- index[[3]]

+        }

+      else return(NULL)

+    }

+    if (any(upper < lower))

+      return (NULL)

+    return(list(name = deparse(v[[2]]), lower=lower, upper=upper))

+  }

+  return(NULL)

+}

+

+parse.varnames <- function(varnames)

+{

+  names <- character(length(varnames))

+  lower <- upper <- vector("list", length(varnames))

+  for (i in seq(along=varnames)) {

+    y <- parse.varname(varnames[i])

+    if (is.null(y)) {

+      stop(paste("Invalid variable subset", varnames[i]))

+    }

+    names[i] <- y$name

+    if (!is.null(y$lower)) {

+      lower[[i]] <- y$lower

+    }

+    if (!is.null(y$upper)) {

+      upper[[i]] <- y$upper

+    }

+  }

+  return(list(names=names, lower=lower, upper=upper))

+}

+

+

+jags.samples <-

+  function(model, variable.names, n.iter, thin=1, type="trace", ...)

+{

+    if (class(model) != "jags")

+      stop("Invalid JAGS model")

+

+    if (!is.character(variable.names) || length(variable.names) == 0)

+      stop("variable.names must be a character vector")

+     

+    if (!is.numeric(n.iter) || length(n.iter) != 1 || n.iter <= 0)

+      stop("n.iter must be a positive integer")

+    if (!is.character(type))

+      stop("type must be a character vector")

+

+    pn <- parse.varnames(variable.names)

+    .Call("set_monitors", model$ptr(), pn$names, pn$lower, pn$upper,

+          as.integer(thin), type, PACKAGE="CoGAPS")

+    update(model, n.iter, ...)

+    ans <- .Call("get_monitored_values", model$ptr(), type, PACKAGE="CoGAPS")

+    for (i in seq(along=variable.names)) {

+      .Call("clear_monitor", model$ptr(), pn$names[i], pn$lower[[i]],

+            pn$upper[[i]], type, PACKAGE="CoGAPS")

+    }

+    return(ans)

+}

+

+nchain <- function(model)

+{

+    if (!inherits(model, "jags"))

+      stop("Invalid JAGS model object in nchain")

+    

+    .Call("get_nchain", model$ptr(), PACKAGE="CoGAPS")

+}

+

+load.module <- function(name, path, quiet=FALSE)

+{

+    if (name %in% list.modules()) {

+        ## This is a stop-gap measure as JAGS 2.1.0 does allow you

+        ## to load the same module twice. This should be fixed in

+        ## later versions.

+        return(invisible()) #Module already loaded

+    }

+    

+    if (missing(path)) {

+        path = getOption("jags.moddir")

+        if (is.null(path)) {

+            stop("option jags.moddir is not set")

+        }

+    }

+    if (!is.character(path) || length(path) != 1)

+        stop("invalid path")

+    if (!is.character(name) || length(name) != 1)

+        stop("invalid name")

+

+    file <- file.path(path, paste(name, .Platform$dynlib.ext, sep=""))

+    if (!file.exists(file)) {

+        stop("File not found: ", file)

+    }

+    if (!isDLLLoaded(file)) {

+        ## We must avoid calling dyn.load twice on the same DLL This

+        ## may result in the DLL being unloaded and then reloaded,

+        ## which will invalidate pointers to the distributions,

+        ## functions and factories in the module.

+        dyn.load(file)

+    }

+    ok <- .Call("load_module", name, PACKAGE="CoGAPS")

+    if (!ok) {

+        stop("module", name, "not found\n", sep=" ")

+    }

+    else if (!quiet) {

+        cat("module", name, "loaded\n", sep=" ")

+    }

+    invisible()

+}

+

+list.modules <- function()

+{

+    .Call("get_modules", PACKAGE="CoGAPS");

+}

+

+isDLLLoaded <- function(file)

+{

+    dll.list <- getLoadedDLLs()

+    for (i in seq(along=dll.list)) {

+        if (dll.list[[i]]["path"][1] == file)

+            return(TRUE)

+    }

+    return(FALSE)

+}

new file mode 100644

@@ -0,0 +1,89 @@

+update.jags <- function(object, n.iter = 1, by, progress.bar, ...)

+{

+    if (!is.numeric(n.iter) || n.iter < 1) {

+        stop("Invalid n.iter")

+    }

+

+    if ("update" %in% names(object)) {

+        ## Old-style jags.model object

+        ## The progress bar was created by the object$update() function

+        

+        if (missing(by))

+            by <- floor(n.iter/50)

+

+        object$update(n.iter, by)

+    }

+    else {

+        ## New jags.model object (in version 1.0.3-6)

+

+        adapting <- .Call("is_adapting", object$ptr(), PACKAGE="CoGAPS") 

+        on.exit(object$sync())

+        

+        if (missing(progress.bar)) {

+            progress.bar <- getOption("jags.pb")

+        }

+        if (!is.null(progress.bar)) {

+            match.arg(progress.bar, c("text","gui","none"))

+            if (progress.bar=="none")

+                progress.bar <- NULL

+        }

+        

+        do.pb <- interactive() && !is.null(progress.bar) && n.iter >= 100

+        if (do.pb) {

+            start.iter <- object$iter()

+            end.iter <- start.iter + n.iter

+            pb <- switch(progress.bar,

+                         "text" = txtProgressBar(start.iter, end.iter,

+                         initial = start.iter, style=3, width=50, 

+                         char=ifelse(adapting,"+","*")),

+                         "gui" = updatePB(start.iter, end.iter, adapting))

+        }

+        

+        ## Set refresh frequency for progress bar

+        if (missing(by) || by <= 0) {

+            by <- min(ceiling(n.iter/50), 100)

+        }

+        else {

+            by <- ceiling(by)

+        }

+

+        ## Do updates

+        n <- n.iter

+        while (n > 0) {

+            .Call("update", object$ptr(), min(n,by), PACKAGE="CoGAPS")

+            if (do.pb) {

+                switch(progress.bar,

+                       "text" = setTxtProgressBar(pb, object$iter()),

+                       "gui" =  setPB(pb, object$iter()))

+            }

+            n <- n - by

+        }

+        if (do.pb) {

+            close(pb)

+        }

+    }

+

+    invisible(NULL)

+}

+

+adapt <- function(object, n.iter, ...)

+{

+    if(.Call("is_adapting", object$ptr(), PACKAGE="CoGAPS")) {

+        update(object, n.iter, ...)

+        if (!.Call("adapt_off", object$ptr(), PACKAGE="CoGAPS")) {

+            warning("Adaptation incomplete. Recreate the model with a longer adaptive phase.")

+        }

+    }

+    invisible(NULL)

+}

+                  

+coef.jags <- function(object, chain = 1, ...) {

+    if (!is.numeric(chain) || chain < 1 || chain > object$nchain()) {

+        stop("Invalid chain")

+    }

+    object$state(internal=FALSE)[[chain]]

+}

+

+variable.names.jags <- function(object, ...) {

+    .Call("get_variable_names", object$ptr(), PACKAGE="CoGAPS")

+}

new file mode 100644

@@ -0,0 +1,26 @@

+read.data <- function(file, format=c("jags","bugs"))

+{

+    format <- match.arg(format)

+    switch(format, "jags"=read.jagsdata(file), "bugs"=read.bugsdata(file))

+}

+

+read.jagsdata <- function(file)

+{

+  e <- new.env()

+  eval(parse(file), e)

+  return(as.list(e))

+}

+

+read.bugsdata <- function(file)

+{

+    bugs.dat <- dget(file)

+    for (n in names(bugs.dat)) {

+        if (!is.null(dim(bugs.dat[[n]]))) {

+            dim(bugs.dat[[n]]) <- rev(dim(bugs.dat[[n]]))

+            bugs.dat[[n]] <- aperm(bugs.dat[[n]])

+        }

+    }

+    return(bugs.dat)

+}

+    

+

new file mode 100644

@@ -0,0 +1,11 @@

+updatePB <- function(start.iter, end.iter, adapting)

+{

+  tcltk:::tkProgressBar(title=ifelse(adapting, "Adapting","Updating"),

+                        label="Iteration 0", min = start.iter, max=end.iter,

+                        initial=start.iter)

+}

+

+setPB <- function(pb, iter)

+{

+  tcltk:::setTkProgressBar(pb, iter, label=paste("Iteration",iter))

+}

new file mode 100644

@@ -0,0 +1,20 @@

+.onLoad <- function(lib, pkg)

+{

+  ## Load the rjags wrapper ...

+  library.dynam("CoGAPS", pkg, lib, local=FALSE)

+

+  ## ... and the modules

+  moddir <- "/usr/local/lib/JAGS/modules-1.0.2"

+  if (is.null(getOption("jags.moddir"))) {

+      options("jags.moddir" = moddir)

+  }

+  load.module("basemod")

+  load.module("gaps")

+

+  .Call("init_jags_console", PACKAGE="CoGAPS")

+

+  ## Set progress bar type

+  if (is.null(getOption("jags.pb"))) {

+      options("jags.pb"="text")

+  }

+}

new file mode 100644

@@ -0,0 +1,20 @@

+.onLoad <- function(lib, pkg)

+{

+  ## Load the rjags wrapper ...

+  library.dynam("CoGAPS", pkg, lib, local=FALSE)

+

+  ## ... and the modules

+  moddir <- "@JAGS_MODULES@"

+  if (is.null(getOption("jags.moddir"))) {

+      options("jags.moddir" = moddir)

+  }

+  load.module("basemod")

+  load.module("gaps")

+

+  .Call("init_jags_console", PACKAGE="CoGAPS")

+

+  ## Set progress bar type

+  if (is.null(getOption("jags.pb"))) {

+      options("jags.pb"="text")

+  }

+}

new file mode 100644

@@ -0,0 +1,11 @@

+updatePB <- function(start.iter, end.iter, adapting)

+{

+    winProgressBar(title=ifelse(adapting, "Adapting","Updating"),

+                  label="Iteration 0", min = start.iter, max=end.iter,

+                  initial=start.iter)

+}

+

+setPB <- function(pb, iter)

+{

+    setWinProgressBar(pb, iter, label=paste("Iteration",iter))

+}

new file mode 100644

@@ -0,0 +1,54 @@

+.onLoad <- function(lib, pkg)

+{

+### First task is to get installation directory of JAGS

+

+    ## Try environment variable first

+    jags.home <- Sys.getenv("JAGS_HOME")

+    if (nchar(jags.home)==0) {

+        keyname <- "SOFTWARE\\JAGS\\JAGS-2.1.0"

+        if (identical(.Platform$r_arch, "x64")) {

+            keyname <- paste(keyname,"-x64", sep="")

+        }

+        ## Look for multi-user installation in registry

+        regkey <- try(readRegistry(keyname, hive = "HLM", maxdepth = 1),

+                      silent = TRUE)

+        if (inherits(regkey, "try-error")) {

+            ## Look for single-user installation in registry

+            regkey <- try(readRegistry(keyname, hive = "HCU", maxdepth = 1),

+                          silent = TRUE)

+        }

+        if (inherits(regkey, "try-error") || is.null(regkey[["InstallDir"]])) {

+            ## Give up

+            stop("Failed to locate JAGS 2.1.0 installation.")

+        }

+        jags.home <- regkey[["InstallDir"]]

+    }

+

+    

+### Add jags.home to the windows PATH, if not already present

+

+    bindir <- file.path(jags.home, "bin")

+    path <- Sys.getenv("PATH")

+    split.path <- strsplit(path, .Platform$path.sep)$PATH

+    if (!any(split.path == bindir)) {

+        path <- paste(bindir, path, sep=.Platform$path.sep)

+        Sys.setenv("PATH"=path)

+    }

+    

+### Set the module directory, if the option jags.moddir is not already set

+    

+    if (is.null(getOption("jags.moddir"))) {

+        options("jags.moddir" = file.path(jags.home, "modules"))

+    }

+    library.dynam("CoGAPS", pkg, lib, local=FALSE)

+    load.module("basemod")

+    load.module("gaps")

+    

+    .Call("init_jags_console", PACKAGE="CoGAPS")

+

+### Set progress bar type

+    

+    if (is.null(getOption("jags.pb"))) {

+        options("jags.pb"="text")

+    }

+}

new file mode 100644

@@ -0,0 +1,163 @@

+# generated automatically by aclocal 1.10 -*- Autoconf -*-

+

+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,

+# 2005, 2006  Free Software Foundation, Inc.

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without

+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A

+# PARTICULAR PURPOSE.

+

+# pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-

+# 

+# Copyright © 2004 Scott James Remnant <scott@netsplit.com>.

+#

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful, but

+# WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+# General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

+#

+# As a special exception to the GNU General Public License, if you

+# distribute this file as part of a program that contains a

+# configuration script generated by Autoconf, you may include it under

+# the same distribution terms that you use for the rest of that program.

+

+# PKG_PROG_PKG_CONFIG([MIN-VERSION])

+# ----------------------------------

+AC_DEFUN([PKG_PROG_PKG_CONFIG],

+[m4_pattern_forbid([^_?PKG_[A-Z_]+$])

+m4_pattern_allow([^PKG_CONFIG(_PATH)?$])

+AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])dnl

+if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then

+	AC_PATH_TOOL([PKG_CONFIG], [pkg-config])

+fi

+if test -n "$PKG_CONFIG"; then

+	_pkg_min_version=m4_default([$1], [0.9.0])

+	AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])

+	if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then

+		AC_MSG_RESULT([yes])

+	else

+		AC_MSG_RESULT([no])

+		PKG_CONFIG=""

+	fi

+		

+fi[]dnl

+])# PKG_PROG_PKG_CONFIG

+

+# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])

+#

+# Check to see whether a particular set of modules exists.  Similar

+# to PKG_CHECK_MODULES(), but does not set variables or print errors.

+#

+#

+# Similar to PKG_CHECK_MODULES, make sure that the first instance of

+# this or PKG_CHECK_MODULES is called, or make sure to call

+# PKG_CHECK_EXISTS manually

+# --------------------------------------------------------------

+AC_DEFUN([PKG_CHECK_EXISTS],

+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl

+if test -n "$PKG_CONFIG" && \

+    AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then

+  m4_ifval([$2], [$2], [:])

+m4_ifvaln([$3], [else

+  $3])dnl

+fi])

+

+

+# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])

+# ---------------------------------------------

+m4_define([_PKG_CONFIG],

+[if test -n "$PKG_CONFIG"; then

+    if test -n "$$1"; then

+        pkg_cv_[]$1="$$1"

+    else

+        PKG_CHECK_EXISTS([$3],

+                         [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`],

+			 [pkg_failed=yes])

+    fi

+else

+	pkg_failed=untried

+fi[]dnl

+])# _PKG_CONFIG

+

+# _PKG_SHORT_ERRORS_SUPPORTED

+# -----------------------------

+AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],

+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])

+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then

+        _pkg_short_errors_supported=yes

+else

+        _pkg_short_errors_supported=no

+fi[]dnl

+])# _PKG_SHORT_ERRORS_SUPPORTED

+

+

+# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],

+# [ACTION-IF-NOT-FOUND])

+#

+#

+# Note that if there is a possibility the first call to

+# PKG_CHECK_MODULES might not happen, you should be sure to include an

+# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac

+#

+#

+# --------------------------------------------------------------

+AC_DEFUN([PKG_CHECK_MODULES],

+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl

+AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl

+AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl

+

+pkg_failed=no

+AC_MSG_CHECKING([for $1])

+

+_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])

+_PKG_CONFIG([$1][_LIBS], [libs], [$2])

+

+if test $pkg_failed = yes; then

+        _PKG_SHORT_ERRORS_SUPPORTED

+        if test $_pkg_short_errors_supported = yes; then

+	        $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "$2"`

+        else 

+	        $1[]_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "$2"`

+        fi

+	# Put the nasty error message in config.log where it belongs

+	echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD

+

+	ifelse([$4], , [AC_MSG_ERROR(dnl

+[Package requirements ($2) were not met:

+

+$$1_PKG_ERRORS

+

+Consider adjusting the PKG_CONFIG_PATH environment variable if you

+installed software in a non-standard prefix.

+])],

+		[AC_MSG_RESULT([no])

+                $4])

+elif test $pkg_failed = untried; then

+	ifelse([$4], , [AC_MSG_FAILURE(dnl

+[The pkg-config script could not be found or is too old.  Make sure it

+is in your PATH or set the PKG_CONFIG environment variable to the full

+path to pkg-config.

+

+To get pkg-config, see <http://pkg-config.freedesktop.org/>.])],

+		[$4])

+else

+	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS

+	$1[]_LIBS=$pkg_cv_[]$1[]_LIBS

+        AC_MSG_RESULT([yes])

+	ifelse([$3], , :, [$3])

+fi[]dnl

+])# PKG_CHECK_MODULES

+

new file mode 100755

@@ -0,0 +1,3 @@

+#!/bin/sh

+rm -f src/Makevars

+rm -f R/unix/zzz.R

new file mode 100644

@@ -0,0 +1,408 @@

+This file contains any messages produced by compilers while

+running configure, to aid debugging if configure makes a mistake.

+

+It was created by CoGAPS configure 2.1.0, which was

+generated by GNU Autoconf 2.63.  Invocation command line was

+

+  $ ./configure --with-jags-include=/usr/local/include/GAPS-JAGS --with-jags-lib=/usr/local/lib --with-jags-modules=/usr/local/lib/JAGS/modules-1.0.2

+

+## --------- ##

+## Platform. ##

+## --------- ##

+

+hostname = Elana-Fertigs-Mac-Pro.local

+uname -m = x86_64

+uname -r = 10.8.0

+uname -s = Darwin

+uname -v = Darwin Kernel Version 10.8.0: Tue Jun  7 16:32:41 PDT 2011; root:xnu-1504.15.3~1/RELEASE_X86_64

+

+/usr/bin/uname -p = i386

+/bin/uname -X     = unknown

+

+/bin/arch              = unknown

+/usr/bin/arch -k       = unknown

+/usr/convex/getsysinfo = unknown

+/usr/bin/hostinfo      = Mach kernel version:

+	 Darwin Kernel Version 10.8.0: Tue Jun  7 16:32:41 PDT 2011; root:xnu-1504.15.3~1/RELEASE_X86_64

+Kernel configured for up to 8 processors.