bio-affy 0.1.0.alpha.1

data/ext/configure.in

@@ -0,0 +1,51 @@
+dnl
+dnl Configuration things for affyR.
+dnl (http://www.cbs.dtu.dk/laurent/download/affyR/
+dnl What is below (and in the other configuration fiels 
+dnl was taken from different configuration scripts for R version 1.3.0.
+dnl
+dnl Acknowledgments: The author(s) of the R configure scripts, Kurt Hornik for the tip with autoconf.
+dnl
+dnl Laurent 2001
+
+
+AC_INIT("DESCRIPTION")
+
+dnl
+dnl Are things (still) the same ?
+dnl (taken from the 'writing R extensions manual')
+
+
+R_ZLIB
+
+
+AC_CHECK_LIB(pthread, pthread_create)
+
+AC_TRY_LINK_FUNC(pthread_create, [use_pthreads=yes], [use_pthreads=no])
+
+AC_MSG_CHECKING([if we can use pthreads])
+AC_MSG_RESULT($use_pthreads)
+
+AC_MSG_CHECKING([if PTHREAD_STACK_MIN is defined])
+AC_COMPILE_IFELSE([
+	#include <pthread.h>
+	#include <limits.h>
+
+      int main () {size_t stacksize = PTHREAD_STACK_MIN + 0x4000;
+}     	  
+    ],[use_pthread_stack_min=yes], [use_pthread_stack_min=no])
+AC_MSG_RESULT($use_pthread_stack_min)
+
+if test "x$use_pthreads" = "xyes"
+then
+if test "x$use_pthread_stack_min" = "xyes"
+    then
+	LIBS="$LIBS -lpthread"
+    	AC_DEFINE(USE_PTHREADS, 1)
+    fi
+fi
+
+
+
+
+AC_OUTPUT(src/Makevars)

data/ext/man/check.cdf.type.Rd

@@ -0,0 +1,22 @@
+\name{check.cdf.type}
+\alias{check.cdf.type}
+\title{CDF file format function}
+\description{This function returns a text string giving the file format
+  for the supplied filename
+}
+\usage{check.cdf.type(filename)
+}
+\arguments{
+  \item{filename}{fullpath to a cdf file}
+}
+\value{Returns a string which is currently one of:
+
+    \item{text}{the cdf file is of the text format}
+    \item{xda}{the cdf file is of the binary format used in GCOS}
+    \item{unknown}{the parser can not handle this format or does not
+      recognize this file as a CDF file}
+
+  }
+
+\author{B. M. Bolstad <bmb@bmbolstad.com>}
+\keyword{IO}

data/ext/man/read.cdffile.list.Rd

@@ -0,0 +1,20 @@
+\name{read.cdffile.list}
+\alias{read.cdffile.list}
+\title{Read CDF file into an R list}
+\description{This function reads the entire contents of a cdf file into
+  an R list structure
+}
+\usage{read.cdffile.list(filename, cdf.path = getwd())
+}
+\arguments{
+\item{filename}{name of CDF file}
+\item{cdf.path}{path to cdf file}
+}
+\value{returns a \code{list} structure. The exact contents may vary
+depending on the file format of the cdf file (see \code{\link{check.cdf.type}})
+}
+\details{
+Note that this function can be very memory intensive with large CDF files.
+}
+\author{B. M. Bolstad <bmb@bmbolstad.com>}
+\keyword{IO}

data/ext/man/read.celfile.Rd

@@ -0,0 +1,23 @@
+\name{read.celfile}
+\alias{read.celfile}
+\title{Read a CEL file into an R list}
+\description{This function reads the entire contents of a CEL file into
+  an R list structure
+}
+\usage{read.celfile(filename,intensity.means.only=FALSE)
+}
+\arguments{
+\item{filename}{name of CEL file}
+\item{intensity.means.only}{If \code{TRUE} then read on only the MEAN section in INTENSITY}
+}
+\value{returns a \code{list} structure. The exact contents may vary
+depending on the file format of the CEL file
+}
+\details{
+The list has four main items. HEADER, INTENSITY, MASKS, OUTLIERS. Note
+that INTENSITY is a list of three vectors MEAN, STDEV, NPIXELS. HEADER
+is also a list. Both of MASKS and OUTLIERS are matrices.
+
+}
+\author{B. M. Bolstad <bmb@bmbolstad.com>}
+\keyword{IO}

data/ext/man/read.celfile.header.Rd

@@ -0,0 +1,22 @@
+\name{read.celfile.header}
+\alias{read.celfile.header}
+\title{Read header information from cel file}
+\description{
+  This function reads some of the header information (appears before probe
+  intensity data) from the supplied cel file.
+}
+\usage{read.celfile.header(filename,info=c("basic","full"),verbose=FALSE)
+}
+\arguments{
+  \item{filename}{name of CEL file. May be fully pathed}
+  \item{info}{A string. \code{basic} returns the dimensions of the chip
+    and the name of the CDF file used when the CEL file was
+    produced. \code{full} returns more information in greater detail.}
+  \item{verbose}{a \code{\link{logical}}. When true the parsing routine
+    prints more information, typically useful for debugging.}
+}
+\value{
+  A \code{list} data structure.
+}
+\author{B. M. Bolstad <bmb@bmbolstad.com>}
+\keyword{IO}

data/ext/man/read.celfile.probeintensity.matrices.Rd

@@ -0,0 +1,31 @@
+\name{read.celfile.probeintensity.matrices}
+\alias{read.celfile.probeintensity.matrices}
+\title{Read PM or MM from CEL file into matrices}
+\description{This function reads PM, MM or both types of intensities
+  into matrices. These matrices have all the probes for a probeset in
+  adjacent rows
+}
+\usage{read.celfile.probeintensity.matrices(filenames, cdfInfo, rm.mask=FALSE, rm.outliers=FALSE, rm.extra=FALSE, verbose=FALSE, which= c("pm","mm","both"))
+}
+\arguments{
+  \item{filenames}{a character vector of filenames}
+  \item{cdfInfo}{a list with items giving PM and MM locations for
+    desired probesets. In same structure as returned by \code{\link[makecdfenv]{make.cdf.package}}}
+  \item{rm.mask}{a \code{\link{logical}}. Return these probes as NA if
+      there are in the [MASK] section of the CEL file}
+  \item{rm.outliers}{a \code{\link{logical}}. Return these probes as NA if
+      there are in the [OUTLIERS] section of the CEL file}.
+  \item{rm.extra}{a \code{\link{logical}}. Return these probes as NA if
+      there are in the [OUTLIERS] section of the CEL file}.
+  \item{verbose}{a \code{\link{logical}}. When true the parsing routine
+    prints more information, typically useful for debugging.}
+
+  \item{which}{a string specifing which probe type to return}
+  
+}
+\value{returns a \code{\link{list}} of \code{\link{matrix}} items. One
+  matrix contains PM probe intensities, with probes in rows and arrays
+  in columns
+}
+\author{B. M. Bolstad <bmb@bmbolstad.com>}
+\keyword{IO}

data/ext/src/CMakeLists.txt

@@ -0,0 +1,39 @@
+cmake_minimum_required(VERSION 2.6)
+
+PROJECT(Biolib_affyio)
+
+SET (M_NAME affyio)
+# SET (M_VERSION 1.8)
+
+IF(NOT BUILD_LIBS)
+  SET (MAP_ROOT ../../../..)
+  SET (CMAKE_MODULE_PATH ${MAP_ROOT}/tools/cmake-support/modules)
+ENDIF(NOT BUILD_LIBS)
+
+SET(USE_ZLIB TRUE)
+SET(USE_RLIB TRUE)
+
+FIND_PACKAGE(Map REQUIRED)
+FIND_PACKAGE(MapLibraries REQUIRED)
+
+INCLUDE_DIRECTORIES(.)
+
+NAME_CLIB()
+
+ADD_LIBRARY(${LIBNAME} SHARED
+     biolib_affyio.c 
+     read_abatch.c 
+     read_cdf_xda.c 
+     read_cdffile2.c 
+     fread_functions.c 
+     read_generic.c
+     read_celfile_generic.c
+)
+
+BUILD_CLIB()
+
+INSTALL_CLIB()
+
+ADD_CUSTOM_TARGET(apidoc
+  COMMAND ${CMAKE_COMMAND} -E echo_append "Building API Documentation for Affyio..."
+)

data/ext/src/Makevars.in

@@ -0,0 +1,3 @@
+PKG_CFLAGS = @CFLAGS@  
+PKG_LIBS = @LIBS@
+PKG_CPPFLAGS = @DEFS@

data/ext/src/Makevars.win

@@ -0,0 +1,2 @@
+PKG_CPPFLAGS += -DHAVE_ZLIB
+PKG_LIBS += -lRzlib

data/ext/src/Rakefile

@@ -0,0 +1,43 @@
+# Generated by mkrf
+require 'rake/clean'
+
+CLEAN.include('*.o')
+CLOBBER.include('libaffyext.so', 'mkrf.log')
+
+SRC = FileList['*.c']
+OBJ = SRC.ext('o')
+CC = 'gcc'
+
+ADDITIONAL_OBJECTS = ''
+
+LDSHARED = "gcc -shared -L/usr/lib64/R/lib -lR"
+
+LIBPATH =  "-L/home/wrk/.rvm/rubies/ruby-1.9.3-p0/lib "
+
+INCLUDES = "-I/home/wrk/.rvm/rubies/ruby-1.9.3-p0/include/ruby-1.9.1 -I/home/wrk/.rvm/rubies/ruby-1.9.3-p0/include/ruby-1.9.1/x86_64-linux -I/home/wrk/.rvm/rubies/ruby-1.9.3-p0/lib/ruby/1.9.1/x86_64-linux -I/home/wrk/.rvm/rubies/ruby-1.9.3-p0/lib/ruby/site_ruby/1.9.1 -I."
+
+LIBS = "-lpthread -lrt -ldl -lcrypt -lm"
+
+CFLAGS = "-fPIC  -O3 -ggdb -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Werror=pointer-arith -Werror=write-strings  -Werror=implicit-function-declaration  -fPIC -I/usr/share/R/include "
+
+RUBYARCHDIR = "#{ENV["RUBYARCHDIR"]}"
+LIBRUBYARG_SHARED = "-Wl,-R -Wl,/home/wrk/.rvm/rubies/ruby-1.9.3-p0/lib -L/home/wrk/.rvm/rubies/ruby-1.9.3-p0/lib -lruby"
+
+task :default => ['libaffyext.so']
+
+rule '.o' => '.c' do |t|
+  sh "#{CC} #{CFLAGS} #{INCLUDES} -c #{t.source}"
+end
+
+desc "Build this extension"
+file 'libaffyext.so' => OBJ do
+  sh "#{LDSHARED} #{LIBPATH} -o libaffyext.so #{OBJ} #{ADDITIONAL_OBJECTS} #{LIBS} #{LIBRUBYARG_SHARED}"
+end
+
+desc "Install this extension"
+task :install => 'libaffyext.so' do
+  makedirs "#{RUBYARCHDIR}"
+  install "libaffyext.so", "#{RUBYARCHDIR}"
+end
+
+

data/ext/src/biolib_affyio.c

@@ -0,0 +1,416 @@
+/*! BIOLIB 'C' interface to affyio - for linking against the Bio* languages
+ *
+ * \defgroup affyio AffyIO
+ *
+ *
+ * Author: Pjotr Prins 2008
+ */
+/*@{*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <R.h>  // For R's Free function only
+#include <biolib_affyio.h>
+
+/*
+
+Test for the shared libray binding. Returns the input value + 55 
+
+*/
+
+int has_affyext(int start)
+{
+  return start + 55;
+}
+
+/*!
+ * Open a cel file using the Affyio library and return a pointer to a CELOBJECT,
+ * which maintains state keeping track of the opened CEL data. The full array
+ * data gets stored in memory - including stddev, npixels, masks and outliers. 
+ *
+ * Use the direct celfile_methods instead, for more effecient memory usage.
+ *
+ * @param celfilename points to a valid Affy CEL file (or .gz edition)
+ *
+ * @return pointer to CELOBJECT
+ * 
+ * @see close_celfile
+ * @see cel_intensities
+ * @see cel_stddev
+ * @see celfile_intensities
+ * @see open_cdffile
+ */
+
+CELOBJECT *open_celfile(const char *celfilename)
+{
+  CELOBJECT *celobject = (CELOBJECT *)malloc(sizeof(CELOBJECT));
+  if (celobject) {
+    memset(celobject,0,sizeof(CELOBJECT));
+    strncpy(celobject->id,"[CEL]",6);
+    celobject->cel = read_cel_file(celfilename, 1);
+  }
+  return celobject;
+}
+
+/**
+ * Close a CELOBJECT opened with open_celfile and frees up RAM
+ *
+ * @param object
+ *
+ */
+
+void close_celfile(CELOBJECT *object)
+{
+  CEL *cel = object->cel;
+
+  Free(cel->header.cdfName);
+  Free(cel->header.DatHeader);
+  Free(cel->header.Algorithm);
+  Free(cel->header.AlgorithmParameters);
+  
+  
+  Free(cel->intensities);
+  Free(cel->stddev);
+  Free(cel->npixels);
+
+  Free(cel->masks_x);
+  Free(cel->masks_y);
+  Free(cel->outliers_x);
+  Free(cel->outliers_y);
+  
+  Free(cel);
+
+  if (object->masks != NULL) { free(object->masks); }
+  if (object->outliers != NULL) { free(object->outliers); }
+  free(object);
+}
+
+/*! @return number of columns on the chip */
+
+unsigned long cel_num_cols(CELOBJECT *object)
+{
+  return object->cel->header.cols;
+}
+
+/*! @return number of rows on the chip */
+
+unsigned long cel_num_rows(CELOBJECT *object)
+{
+  return object->cel->header.rows;
+}
+
+/*! @return number of masked probes */
+
+unsigned long cel_num_masks(CELOBJECT *object)
+{
+  return object->cel->nmasks*2;
+}
+
+/*! @return number of outliers */
+
+unsigned long cel_num_outliers(CELOBJECT *object)
+{
+  return object->cel->noutliers*2;
+}
+
+
+/*! @return number of cells (probes) - [INTENSITY]->NumberCells (rows*cols) */
+
+unsigned long cel_size(CELOBJECT *object)
+{
+  return object->cel->header.rows * object->cel->header.cols;
+}
+
+/*! @return number of intensities (probes) */
+
+unsigned long cel_num_intensities(CELOBJECT *object)
+{
+  return object->cel->header.rows * object->cel->header.cols;
+}
+
+/*! 
+ * @parameter index of cel/probe 
+ * @return an intensity value 
+ * @see cel_pm
+ */
+
+double cel_intensity(CELOBJECT *object, unsigned long index)
+{
+  return object->cel->intensities[index];
+}
+
+/*! 
+ * @parameter x pos on chip
+ * @parameter y pos on chip
+ * @return an intensity value 
+ * @see cel_pm
+ */
+
+double cel_intensity_xy(CELOBJECT *object, unsigned long x, unsigned long y)
+{
+  return object->cel->intensities[y*cel_num_rows(object)+x];
+}
+
+/*! @return a double array to the cel/probe intensities 
+ * @see cel_pm
+ */
+
+double *cel_intensities(CELOBJECT *object)
+{
+  return object->cel->intensities;
+}
+
+/*! @return the stddev for the cel/probe */
+
+double cel_stddev(CELOBJECT *object, unsigned long index)
+{
+  return object->cel->stddev[index];
+}
+
+/*! @return a double array to the stddev */
+
+double *cel_stddevs(CELOBJECT *object)
+{
+  return object->cel->stddev;
+}
+
+/*! 
+ * @param index is the nth item in the mask list
+ * @return the cel/probe mask index 
+ * @see cel_num_masks
+ */
+
+unsigned int cel_mask(CELOBJECT *object, unsigned long index)
+{
+  CEL *cel = object->cel;
+  if (!object->masks) {
+    // initialize
+    object->masks = malloc(cel->nmasks*2*sizeof(short));
+    int i;
+    for (i=0; i < cel->nmasks; i++){
+      object->masks[i] = (int)cel->masks_x[i];
+      object->masks[cel->nmasks + i] = (int)cel->masks_y[i];
+    }
+  }
+  return object->masks[index];
+}
+
+/*!
+ * @param index is the nth item in the outlier list
+ * @return the outlier cel/probe index
+ * @see cel_num_outliers
+ */
+unsigned int cel_outlier(CELOBJECT *object, unsigned long index)
+{
+  CEL *cel = object->cel;
+  if (!object->outliers) {
+    // initialize
+    object->outliers = malloc(cel->noutliers*2*sizeof(short));
+    int i;
+    for (i=0; i < cel->noutliers; i++){
+      object->outliers[i] = (int)cel->outliers_x[i];
+      object->outliers[cel->noutliers + i] = (int)cel->outliers_y[i];
+    }
+  }
+  return object->outliers[index];
+}
+
+/* ========================================================================= */
+
+static void cdf_alloc_probesets(CDFOBJECT *cdfobject)
+{
+  cdfobject->probeset = malloc(sizeof(CDFPROBESET)*cdf_num_probesets(cdfobject)); 
+  memset(cdfobject->probeset,0,sizeof(CDFPROBESET));
+}
+
+/*
+ * Fill the structures that keep track of probesets and probes
+ */
+
+static void cdf_calc_text_probe_refs(CDFOBJECT *cdfobject)
+{
+  cdf_text my_cdf;
+  memcpy(&my_cdf,&cdfobject->text,sizeof(cdf_text));
+  CDFPROBESET *probeset = cdfobject->probeset;
+ 
+  int i,j,k,l;
+  for (i=0; i < my_cdf.header.numberofunits; i++) {
+    for (j=0; j < my_cdf.units[i].numberblocks; j++) {
+      CDFPROBESET *pset = &probeset[i];
+      // here we copy the probeset name:
+      strncpy(pset->name,my_cdf.units[i].blocks[j].name,sizeof(pset->name)-1);
+      // get the number of probes
+      int cells = my_cdf.units[i].blocks[j].num_cells;
+      pset->isQC = 0;
+      pset->pm_num = cells/2;
+      pset->mm_num = cells/2;
+      pset->pm = malloc(sizeof(CDFPROBE)*pset->pm_num);
+      pset->mm = malloc(sizeof(CDFPROBE)*pset->mm_num);
+      /*
+      // assuming even cells are PM and odd cells are MM
+      for (k=0; k < cells/2; k++) {
+        CDFPROBE *pm = &pset->pm[k];
+        CDFPROBE *mm = &pset->mm[k];
+        pm->x = my_cdf.units[i].blocks[j].probes[k*2].x;
+        pm->y = my_cdf.units[i].blocks[j].probes[k*2].y;
+        mm->x = my_cdf.units[i].blocks[j].probes[k*2+1].x;
+        mm->y = my_cdf.units[i].blocks[j].probes[k*2+1].y;
+      }
+      */
+      // assuming PM always sits above an MM cel
+      for (k=0; k < cells/2; k++) {
+        CDFPROBE *pm = &pset->pm[k];
+        CDFPROBE *mm = &pset->mm[k];
+        pm->x = my_cdf.units[i].blocks[j].probes[k*2].x;
+        pm->y = my_cdf.units[i].blocks[j].probes[k*2].y;
+        mm->x = my_cdf.units[i].blocks[j].probes[k*2+1].x;
+        mm->y = my_cdf.units[i].blocks[j].probes[k*2+1].y;
+        if (pm->x!=mm->x) { error("PM cel does not sit above MM cel"); }
+        if (pm->y > mm->y) {
+          int swap = pm->y; pm->y = mm->y; mm->y = swap;
+        }
+      }
+    }
+  }
+}
+
+/*! 
+ * Open a cdf file using the Affyio library and return a pointer to a CDFOBJECT,
+ * which maintains state keeping track of the opened CDF data. Unlike the Affyio
+ * internal representation the Biolib affyio CDF methods represent a unified
+ * layout for Affymetrix chips. Basically every probeset can return the name, probe
+ * values (PM, MM) and QC. Loading all other information is trivial, as Affyio
+ * makes it available - but not implemented here, at this point.
+ *
+ * @note FIXME: XDA format not tested
+ *
+ * @param cdffilename points to a valid Affy CDF file (textual or XDA binary)
+ *
+ * @return pointer to CDFOBJECT
+ * 
+ * @see close_cdffile
+ */
+
+CDFOBJECT *open_cdffile(const char *cdffilename)
+{
+  CDFOBJECT *cdfobject = (CDFOBJECT *)malloc(sizeof(CDFOBJECT));
+  if (cdfobject) {
+    memset(cdfobject,0,sizeof(CDFOBJECT));
+    strncpy(cdfobject->id,"[CDF]",6);
+    if (isTextCDFFile(cdffilename)) {
+      cdfobject->isText = 1;
+      if (!read_cdf_text(cdffilename, &cdfobject->text)) {
+        free(cdfobject);
+        cdfobject = NULL;
+      }
+      else {
+        cdfobject->cols = cdfobject->text.header.cols;
+        cdfobject->rows = cdfobject->text.header.rows;
+        cdf_alloc_probesets(cdfobject);
+        cdf_calc_text_probe_refs(cdfobject);
+      }
+    }
+    if (check_cdf_xda(cdffilename)) {
+      if (!read_cdf_xda(cdffilename,&cdfobject->xda)) {
+        free(cdfobject);
+        cdfobject = NULL;
+      }
+      else {
+        cdfobject->cols = cdfobject->xda.header.cols;
+        cdfobject->rows = cdfobject->xda.header.rows;
+        cdf_alloc_probesets(cdfobject);
+      }
+    }
+  }
+  return cdfobject;
+}
+
+
+void close_cdffile(CDFOBJECT *cdfobject)
+{
+    if (cdfobject) {
+      free(cdfobject->probeset);
+      if (cdfobject->isText) {
+        dealloc_cdf_text(&cdfobject->text);
+      }
+      else {
+        dealloc_cdf_xda(&cdfobject->xda);
+      }
+    }
+}
+
+/*! @return number of probesets (units*blocks) including QC units */
+
+unsigned long cdf_num_probesets(CDFOBJECT *cdfobject)
+{
+  unsigned long probesets = 0;
+  if (cdfobject->isText) {
+    probesets = cdfobject->text.header.NumQCUnits;
+    int i,j;
+    for (i=0; i < cdfobject->text.header.numberofunits; i++) {
+      probesets += cdfobject->text.units[i].numberblocks;
+    }
+  }
+  else {
+    probesets = cdfobject->xda.header.n_units +
+                cdfobject->xda.header.n_qc_units;
+  }
+  return probesets;
+}
+
+/*!
+ * @return CDFPROBESET related to probeset number
+ */
+CDFPROBESET *cdf_probeset_info(CDFOBJECT *cdfobject, unsigned int probeset)
+{
+  return &cdfobject->probeset[probeset];
+}
+
+/*!
+ * @return CDFPROBE related to probe in probeset
+ */
+CDFPROBE *cdf_pmprobe_info(CDFOBJECT *cdfobject, unsigned int probeset, unsigned int probe)
+{
+  return &cdfobject->probeset[probeset].pm[probe];
+}
+
+/*!
+ * @return CDFPROBE related to probe in probeset
+ */
+CDFPROBE *cdf_mmprobe_info(CDFOBJECT *cdfobject, unsigned int probeset, unsigned int probe)
+{
+  return &cdfobject->probeset[probeset].mm[probe];
+}
+
+/*! 
+ * \note FIXME: in progress...
+ *
+ * @return PM value (perfect match) of the probe number in probeset; -1 on error 
+ */
+
+double cel_pm(CELOBJECT *celobject, CDFOBJECT *cdfobject, unsigned int probeset, unsigned int probe)
+{
+  CDFPROBESET *pset = &cdfobject->probeset[probeset];
+  if (pset) {
+    CDFPROBE *p = &pset->pm[probe];
+    return cel_intensity_xy(celobject, p->x, p->y);
+  }
+  return -1;
+}
+
+/*! 
+ * @return MM value (mismatch) of the probe number in probeset; -1 on error 
+ */
+double cel_mm(CELOBJECT *celobject, CDFOBJECT *cdfobject, unsigned int probeset, unsigned int probe)
+{
+  CDFPROBESET *pset = &cdfobject->probeset[probeset];
+  if (pset) {
+    CDFPROBE *p = &pset->mm[probe];
+    return cel_intensity_xy(celobject, p->x, p->y);
+  }
+  return -1;
+}
+
+
+
+/*@}*/