Hi, 
 
My general goal is to find a coding strategy to efficiently store and
retrieve drawing routines for different plots. 
 
This is my approach so far. In a single text file I store multiple drawing
routines where each routine draws a different plot. 
 
A drawing routine may look like this:
 
          panel.mean <- function(means,...){
                                 dots <- list(...)
                                 dots$x <- means$data$trial.bin
                                 dots$y <- means$data$Freq
                                 dots$group<-
means$data$expected.hierarchyTo
                                 dots$typ <- "l"
                                 dots$lty <- 3
                                 dots$lwd <- 1
                                 do.call(panel.superpose,dots)
                             }
          arg <- list()
          arg$formula <- formula(Freq~trial.bin|subj)
          arg$group   <- quote(expected.hierarchyTo)
          arg$data <- atm.errors.intrusion.none[["frequency~hdt*prac*subj"]]
          arg$as.table <- TRUE
          arg$layout <- c(3,4)
          arg$col <- c("green","blue","red")
          arg$lwd <- 2
          arg$typ <- "b"
          arg$pch <- 17
          arg$lty <- 1
          arg$xlab <- "Trial Bin"
          arg$ylab <- "Frequency of Error Type"
          arg$main <- "ATM Experiment: Frequency of Intrusion-none Button
Presses During Error Trials\nAs A Function of Hierarchy Traversal Distance
To Current Expected Button Press"
          arg$scales <- list(rot=c(90,90))
          arg$sub <- date()
          arg$means <-
list(data=gsummary(subset(arg$data,select=c("expected.hierarchyTo","trial.bi
n","Freq")),form=~expected.hierarchyTo/trial.bin,mean))
          arg$par.settings <-
list(background=list(col="white"),strip.background=list(col="white"))
          arg$panel <-
function(x,y,means,...){panel.mean(means,...);panel.superpose(x,y,...)}
          print(do.call("xyplot",arg))
          key <-
draw.key(list(background="white",border=TRUE,text=list(lab=levels(arg$data$e
xpected.hierarchyTo)),lines=list(col=arg$col,pch=arg$pch,lty=arg$lty,lwd=arg
$lwd)))
 
vp<-viewport(x=0.9,y=grobHeight(key)+unit(0.07,"npc"),just=c("right","top"),
width=grobWidth(key),height=grobHeight(key))
          pushViewport(vp)
          grid.draw(key)        
 
As you can see each routine is a sequence of commands required to draw a
single plot. Each routine is separated in the text file by comments. If I
wanted all these plots drawn I could source the file, but often I want only
one. Each time I want to draw one of these I 1) open the text file, 2)
scroll to the code for the desired plot, then copy and paste the code into
the R console. Is there a more efficient way to store and retrieve these
drawing routines?
 
For example, I am exploring the following idea. Save the plot routines as
expressions in a list object. The result is a list, l, with x components,
where each component contains the routine to draw a plot as an expression.
To draw a single plot all I need to do is type eval(l[[x]]). 
 
While this approach has succeeded, it has some drawbacks. One drawback comes
about because I also want to be able to copy and paste directly from the
routine as it is written into the R console. If I use the expression command
to convert the routine to an expression, then each statement must be
separated by commas. Using that syntax I cannot copy and paste command1
through command3 (see below) to the console because the commas will be
included and cause a syntax error.
 
expression(
    command1,
    command2,
    command3, 
    ect.
)
 
Another option is to call parse(file="") and then run each command in
sequence without commas. The problem here is that parse does not work on
multi-line functions at the command line (see below). Why doesn't this work?

 
> parse(file="")
?function(x){x<-9}
expression(function(x) {
    x <- 9
})
 
> parse(file="")
?function(x){x<-9;x<-8}
Error in parse(file, n, text, prompt) : parse error
> 

> parse(file="")
?function(x){x<-9
Error in parse(file, n, text, prompt) : parse error

Using parse also requires knowing how many statements will be processed
ahead of time. If I go this route I would like some way to automate that as
well. 
 
Assuming the parse problem described above cannot be fixed, there are two
other possible options. 
 
1) Rather than have multiple drawing routines in a single file, have each
drawing routine in it's own file. In that case the syntax in the file is
just as it would be at the command line, which is the way I want it.
Furthermore, calling prase with a file now works--that is, it can handle
multiple line functions with ease. The only real draw back to this is that
having separate files for each and every plot may be overwhelming. I'd
rather have a series of related plots in the same text file than the same
folder. But, I could get over that.
 
2) Convert the drawing routines to functions without arguments--not
expressions. In this scheme each component of the list would contain a
function with the drawing commands. This approach does work. The only reason
I haven't implemented this and moved on is because a series of drawing
commands seems intuitively more like a complex expression than a function.
But, may be this is wrong. Comments? 
 
Thanks for any help you can provide, 
Steve Lacey
 
> R.version
         _              
platform i386-pc-mingw32
arch     i386           
os       mingw32        
system   i386, mingw32  
status                  
major    2              
minor    1.1            
year     2005           
month    06             
day      20             
language R  

	[[alternative HTML version deleted]]


