chunklist <- function(vec, chunksize) {
  ret <- list()
  counter <- 1
  idx <- seq(1, length(vec), by=chunksize)
  lastidx <- idx[length(idx)]
  for (i in idx) {
    if (i == lastidx && i+chunksize-1 > length(vec)) {
      ret[[counter]] <- vec[i:length(vec)]
    } else {
    ret[[counter]] <- vec[i:(i+chunksize-1)]
  }
    counter <- counter +1
  }
  ret
}

bspec.write <- function(filename, xydata, name) {
  con = file(description=filename, open='w')
  writeLines(paste('##TITLE= ',name,sep=''), con=con)
  writeLines('##JCAMP-DX= 4.24\n##DATA TYPE= UV/VIS SPECTRUM\n##DATA CLASS= XYDATA', con=con)
  writeLines('##XLABEL= Bit Position\n##YLABEL= Normalized Frequency', con=con)
  writeLines('##XFACTOR= 1.0\n##YFACTOR= 1.0', con=con)
  writeLines('##FIRSTX= 1.0\n##LASTX= 1052.0', con=con)
  writeLines('##MAXY= 1.0\n##MINY= 0.0', con=con)    
  writeLines(paste('##NPOINTS= ',nrow(xydata),sep=''), con=con)
  writeLines('##XYDATA= (X++(Y..Y))', con=con)

  chunks <- .chunklist(round(xydata[,2],2), 10)
  i <- 1
  for (chunk in chunks) {
    writeLines(paste(i, paste(chunk, sep=' ', collapse=' '), sep=' '), con=con)
    i <- i+10
  }
  
  writeLines("##END=", con=con)
  close(con)
}

vot2df( doc, isURL=FALSE, isString=FALSE)

Currently it will only handle tabular data corresponding to the TABLEDATA element of the VOTable schema. In addition it will handle the following primitive data types and convert them to R types

Update (10/20/2007): The reader can now handle the case where cells are empty. The corresponding data.frame will contain an NA at those positions

obj.R provides a useful utility function which brings up a graphical table that basically lists all the variables (or functions or both) in the current workspace. That it is, it considers env = .GlobalEnv. A screenshot can be seen here

The code requires that you have Tcl/TK as well as the Tktable widget installed on your system. To use the function called obj.browse simply source obj.R. The synatx of the function is

obj.browse(which=c('all','funcs','vars'), height=-1, width=-1)

which='all'   - Display all variables and functions. In this case the rows are 
                sorted on the basis of the 'Class' column
which='funcs' - Display only functions
which='vars'  - Display only variables

height=-1     - How many rows to display. Default is to use the Tktable default 
width=-1      - How many columns to display. Default is to use 3

yum install tktable

Fischer et al. (Fischer, I.,; Poland, J.,Amplifying the Block Matrix Structure for Spectral Clustering, In M. van Otterlo et al. (Editors), Proceedings of the 14th Annual Machine Conference of Belgium and the Netherlands, pp. 21-28, 2005) proposed an alternative method which amplifies the block structure of an affinity matrix by using asymmetric affinity matrices generated from Gaussian kernels. They then evaluate the Laplacian or a conductivity matrix which is then decomposed using the SVD.

specclusAS is an R package that is a translation of the original Matlab code written by Fischer et al. and has functions to perform both symmetric and asymmetric spectral clustering and also provides access to functions that can compute an asymmetric affinity matrix as well as the conductivity matrix.

r2test <- function(d, cutoff=0.8) {
  if (cutoff > 1 || cutoff <= 0) {
    stop(" 0 <= cutoff < 1")
  }
  if (!is.matrix(d) && !is.data.frame(d)) {
    stop("Must supply a data.frame or matrix")
  }
  r2cut = sqrt(cutoff);
  cormat <- cor(d);
  bad.idx <- which(abs(cormat)>r2cut,arr.ind=T);
  bad.idx <- matrix( bad.idx[bad.idx[,1] > bad.idx[,2]], ncol=2);
  drop.idx <- ifelse(runif(nrow(bad.idx)) > .5, bad.idx[,1], bad.idx [,2]);
  if (length(drop.idx) == 0) {
      1:ncol(d)
  } else {
      (1:ncol(d))[-unique(drop.idx)]
  }
}

d <- data.frame(...)
dropidx <- apply(d, 2, function(x) { length(which(x == 0))/length(x) > .8 })
d <- d[, !dropidx]

parseCall() performs this job by parsing a call object to determine parameter names and associated values. The return value is a named list with the names being the names of the parameters and each element is the value that was passed to that parameter.

As an example consider the following function, which simply returns the call to itself

foo <- function(x, second.arg, y) {
        match.call()
}

> val <- foo(2)            
> class(val)
[1] "call"
> parseCall(val)
$x
[1] "2"

> val <- foo(x=runif(10), second.arg=12.34)
> parseCall(val)
$x
[1] "runif(10)"

$second.arg
[1] "12.34"

> val <- foo(x=function(z) {z^2}, y=ls())
> parseCall(val)
$x
[1] "function(z){z^2}"

$y
[1] "ls()"

fcbf(x, y, thresh)

entropy(x, base=exp(1))            # Entropy of a variable
entropy.joint(x, y, base=exp(1))    # Joint entropy of two variables
entropy.cond(x, y, base=exp(1))     # Conditional entropy of X given Y
SU(x, y, base=exp(1))               # Symmetric uncertainty of X & Y

integrate2D.xy <- function(x, y, z) {

    hx <- diff(x)[1]
    hy <- diff(y)[1]

    trap <- function(xx) {
        xx[1] + 2*sum(xx[-c(1,length(xx))]) + xx[length(xx)]
    }
    yvals <- hx * apply(z,2, trap) / 2
    trap(yvals) * hy/2
}

> x <- seq(-1,1, length=100)
> y <- seq(0,1, length=100)
> z <- outer(x,y, function(x,y) {exp(x) + cos(y)})
> integrate2D.xy(x,y,z)
[1] 4.03341

> f <- function(args) { exp(args[1]) + cos(args[2]) }
> adapt(2, c(-1,0), c(1,1), 100, functn=f)
       value       relerr       minpts       lenwrk        ifail
    4.033344 3.458066e-07          165           73            0

nbr.behavior(act, desc, dist=FALSE, do.plot=TRUE, ...)

rescale <- function(x, newrange) {
    newmin <- min(newrange)
    newmax <- max(newrange)
    oldrange <- range(x)
    y <- (newmax - newmin) / (oldrange[2] - oldrange[1])
    newmin + (x - oldrange[1]) * y
}

> x <- runif(20)
> newx <- rescale(x, c(-2,2))

distance <- levdist(source, target) 

R CMD INSTALL spe_1.0.tar.gz 

R CMD SHLIB jpc.c 

>dyn.load('jpc.so')
>source('jpc.R')
>clus <- jpc(dat, j=3, k=1, diss=FALSE) 

bqsar(x,y,sigma=.25) 

bwidth <- dpih(z)
b <- seq(min(z)-0.1, max(z)+0.1+bwidth, by=bwidth)
hist(x, breaks=b) 

cd rcdk
ant clean jar

R CMD build rcdk
R CMD INSTALL rcdk*.gz

library(rcdk)

# load multiple structure files
moleculelist <- load.molecules(c('data/mol1.sdf','data/mol2.xyz','data/mol3.hin'))

# draw a 2D structure
molecule <- draw.molecule()

# view 2D structures as a grid
view.molecule.2d(moleculelist)

# view a single 2D structure
view.molecule.2d(moleculelist[[1]])

# get fingerprints
get.fingerprint(moleculelist[[1]])

# generate SMILES for a set of molecules
lapply(moleculelist, get.smiles)

# view a 3D structure
view.molecule.3d('structure.xyz')

# view a 3D structure and supply a Jmol script
view.molecule.3d('structure.xyz', 'select *; spacefill on;')