···
#------------------------------------------------------------#
#--- COMMAND LINE Script I Use --- #
#--- requires ext/default_plotter and --- #
#--- ext/enum_from - they follow --- #
# reads in a list of csv files that my boss gave me, and takes out
# some experiment data, and adds it into the default plotter to make
# graphs! Not really that complicated.
ls *.csv | ruby -r ext/default_plotter -r ext/enum_from -ne '
lines = File.readlines(chomp).map {|i| i.chomp.split(/\t/)}
header = lines.shift
plotter = `which gnuplot`.chomp
lines.inject() {|arr, line|
arr << header.inject(Hash.new) {|h, f| h[f] = line.shift; h}
}.each {|row|
id = row["cloneid"].gsub(/\//, "_")
file = "../../results/#{chomp.gsub(/\.csv$/, "")}/#{id}.png"
Dir.mkdir(File.dirname(file)) unless FileTest.exists?(File.dirname(file))
control, deprived = * %w{CON DEP}.map {|tag|
[0, *[3,6,9,12].map {|i| row["#{i}_#{tag}"].to_f - row["0_CON"].to_f}]
}
xlabel, ylabel, xtics, ytics, xrange, yrange = nil
xlabel = ["Gene Title", "Gene Symbol"].map {|k| "#{k}: #{row[k]}"}
xlabel << ""
table = [%w{Time Control Deprived}]
[0, 3, 6, 9, 12].each_with_index {|e, i|
table << [e.to_s.rjust(3), control[i], deprived[i]].map {|i| i.to_s}
}
frac = /^(-?\d*)(\.?\d*)$/
ilens = (1..2).map {|i|
table.map {|a| a[i] =~ frac ? $1.length : 0}.max
}
flens = (1..2).map {|i|
table.map {|a| a[i] =~ frac ? $2.length : 0}.max
}
(1..2).each {|i|
table.each {|a|
a[i] = "#{$1.rjust(ilens[i-1])}#{$2.ljust(flens[i-1])}" if a[i] =~ frac
}
}
lens = (0...(table[0].length)).map {|i| table.map {|a| a[i].length}.max}
dlens = (0...(table[0].length)).map {|i| table.from(1).map {|a|
a[i].length}.max}
table.each_with_index {|arr, ai|
index = 0
if ai == 0 then
xlabel << arr.map {|item|
actualmax = lens[index]
item.center(actualmax+2)
}.join(" ")
next
end
xlabel << arr.map {|item|
actualmax = lens[index]
datamax = dlens[index]
v = item.rjust(datamax+1)
v.center(actualmax+1)
index += 1
v
}.join(" ")
}
xlabel = xlabel.join("\\n")
DefaultPlotter.data {|files|
[control, deprived].each {|arr|
files.add {|filehandle|
arr.each_with_index {|e, i|
filehandle.puts(e, i*3)
}
}
}
DefaultPlotter.plot(file, plotter, id, xlabel, ylabel, xtics,
ytics, xrange, yrange, "png") {|plot|
files.each_path_with_index {|path, idx|
plot.add(File.expand_path(path), %w{Control Deprived}[idx],
"lines", "2:1")
}
}
}
}
'
#------------------------------------------------------------#
#--- ext/enum_from --- #
# Allows you to take a nth tail...
module Enumerable
def from(index)
result =
self.each_with_index {|e, i|
next unless i >= index
yield e if block_given?
result << e
}
result
end
end
#------------------------------------------------------------#
#--- ext/default_plotter ---#
#--- requires ext/gnuplot - which follows ---#
# Just an alias for a `plotting' object.
require "ext/gnuplot"
DefaultPlotter = GnuPlot
#------------------------------------------------------------#
#--- ext/gnuplot ---#
#--- requires ext/plot and ext/singleton_class - which follow ---#
# Set up to use gnuplot to make wonderful graphs.
require 'ext/plot'
require 'ext/singleton_class'
require 'tempfile'
module GnuPlot
end
# Take an output (`file' to write to, basically)
# a title (what to call graph)
# an xlabel (what to call x-axis)
# a ylabel (what to call y-axis)
# an xtics (how to mark x-axis)
# a ytics (how to mark y-axis)
# an xrange (what part of x-axis to show)
# a yrange (what part of y-axis to show)
# a format (what to write `as' - png, gif, eps, etc)
# block - takes the `plot' object and interacts with it.
#
# the plot object the block gets has the following methods:
# close : closes the plot command file - now useable for making gnuplots!
# add(path, title, style, use) : add the data from the file with
path, use title and style, with columns use
# path : gives the path of the file containing the gnuplot commands
def GnuPlot.plotter(output, title=nil, xlabel=nil, ylabel=nil,
xtics=nil, ytics=nil, xrange=nil, yrange=nil, format=nil, &block)
raise ArgumentException, "No block given" if block.nil?
if Hash === output then
h = output
syms = [:output, :title, :xlabel, :ylabel, :xtics, :ytics,
:xrange, :yrange, :format]
make_gnuplot(*syms.map {|sym| h[sym]}, &block)
end
raise ArgumentException, "Cannot accept nil output destination." if
output.nil?
gpcmd = Tempfile.new('run_gnuplot_cmds_script')
[["set terminal #{format}", false],
["set output \"#{output}\"", false],
["set pointsize 1.4", false],
["set title \"#{title}\"", title.nil?],
["set xlabel \"#{xlabel}\"", xlabel.nil?],
["set ylabel \"#{ylabel}\"", ylabel.nil?],
["set xrange [#{xrange}]", xrange.nil?],
["set yrange [#{yrange}]", yrange.nil?],
["set xtics (#{xtics})", xtics.nil?],
["set ytics (#{ytics})", ytics.nil?]].each {|str, skip|
gpcmd.puts str unless skip
}
handle = Object.new
closed = false
gpcmds =
handle.singleton_def(:close) {
next if closed
closed = true
index = 0
space = ' ' * 'plot'.length
cmds =
gpcmds.each_with_index {|c, i|
cmds << "#{i == 0 ? 'plot' : space} #{c}"
}
gpcmd.puts cmds.join(",\\\n")
gpcmd.close
}
handle.singleton_def(:add) {|path, title, style, using|
cmd = path.inspect
if using.nil? then
cmd += ' using 1:2'
else
cmd += " using #{using}"
end
if title.nil? then
cmd += ' notitle'
else
cmd += " title #{title.inspect}"
end
cmd += " with #{style}" unless style.nil?
gpcmds << cmd
}
handle.singleton_def(:path) {
gpcmd.path
}
result = nil
begin
result = block[handle]
gpcmd.unlink
rescue Exception
begin
gpcmd.unlink
rescue Exception
end
raise
end
result
end
# Turns a set of points into something gnuplot understands as separate
coordinates.
def GnuPlot.make_point(*points)
points.join("\t")
end
# Make GnuPlot a plot!
GnuPlot.extend(Plot)
# Make a gnuplot range! here, we have a name for the range (x?, y?),
and the ends.
# the ends can be numbers, or nolow nohigh...
def GnuPlot.make_range(name, a, b, errorp=nil)
error = errorp.nil? ? Proc.new{|exc, msg|
raise exc, msg
} : Proc.new {|exc, msg|
errorp[exc, msg]
return
}
a = a.strip.downcase
b = b.strip.downcase
error[ArgumentError, "#{name}: both points are #{a.upcase}."] if a
=~ /^no(low|high)$/ && a == b
return make_range[name, b, a] if b == 'nolow' || a == 'nohigh'
floata, floatb = *[a, b].map {|c|
!(/^(-|\+)?(\d+)?\.?(\d+)?$/.match(c).nil? || /\d/.match(c).nil?)}
noa, nob = *[a, b].map {|c| ['nolow', 'nohigh'].include?(c)}
error[ArgumentError, "Invalid points: #{a}, #{b}."] if !(floata ||
noa) && !(floatb || nob)
a = (a == 'nolow') ? '' : a.to_f
b = (b == 'nohigh') ? '' : b.to_f
a, b = b, a if Float === a && Float === b && b < a
a, b = a.to_s, b.to_s
"#{a}:#{b}"
end
#------------------------------------------------------------#
#--- ext/plot ---#
#--- requires ext/singleton_class - which follows ---#
require 'tempfile'
require 'ext/singleton_class'
module Plot
# Output is `where' to go with the graph (file)
# plotter is the actual command to invoke.
# the rest, except errorp and debugp are the same as gnuplot.plotter args
# errorp and debugp are procs toc all with error and debug information.
#
# Needs a block - that block is passed a plot object who's sole method is add,
# which is the same as the add method from the object yieled by
plotter's block.
def plot(output, plotter, title=nil, xlabel=nil, ylabel=nil,
xtics=nil, ytics=nil, xrange=nil, yrange=nil, format=nil, errorp=nil,
debugp=nil)
error = errorp.nil? ? Proc.new{|exc, msg|
raise exc, msg
} : Proc.new {|exc, msg|
errorp[exc, msg]
return
}
debug = debugp.nil? ? Proc.new {} : debugp
error[ArgumentError, 'Block not given for Plot # plot. A block is
required.'] unless block_given?
plotargs = [output, title, xlabel, ylabel, xtics, ytics, xrange,
yrange, format]
plotblock = Proc.new {|plot_handle|
yield(Object.new.singleton_def(:add) {|*args| plot_handle.add(*args)})
plot_handle.close
debug[:command_file, File.readlines(plot_handle.path).map {|i| i.chomp}]
`#{plotter} #{plot_handle.path}`
}
plotter(*plotargs, &plotblock)
end
# Basically, make an object that is a database of plotting files.
# errorp and debugp are the same as above.
# Takes a block - this block gets the `database'
# this database has the following methods:
# add - calling this gets you a filehandle back in the block add gets
# this filehandle can be given points to add, and when the block
# is done, the file gets added to the end of the list of data files
# use_file(fname) - adds fname to the end of the list of data files
# each_path_with_index - use block to go over each file in the list of
# of data files and have the index in the list, too
# each_path - same as above, no index
# at the end of the block, the database's files are `cleared'
def data(errorp=nil, debugp=nil)
error = errorp.nil? ? Proc.new{|exc, msg|
raise exc, msg
} : Proc.new {|exc, msg|
errorp[exc, msg]
return
}
debug = debugp.nil? ? Proc.new {} : debugp
error[ArgumentError, 'Block not given for Plot # data. A block is
required.'] unless block_given?
handle = Object.new
files =
done = Proc.new {files.each {|f| f.unlink}}
add = Proc.new {|file| files << file}
enum = Proc.new {|block, index|
files.each_with_index {|f, i|
block[f.path, i] if index
block[f.path] unless index
}
}
point = Proc.new {|*args| make_point(*args)}
handle.instance_eval {
@done, @add, @enum,
@error, @debug, @point = done, add, enum,
error, debug, point
}
def handle.add
unless block_given? then
@done
@error[ArgumentError, 'Block not given for Plot # data #
handle.add. A block is required.']
end
file = Tempfile.new('plotdata')
filehandle, point = Object.new, @point
filehandle.singleton_def(:puts) {|*points|
file.puts(point[*points])
}
yield filehandle
file.close(false)
@debug[:data_file, File.readlines(file.path).map {|l| l.chomp}]
@add[file]
end
def handle.use_file(fname)
@error[ArgumentError, "File #{fname} does not exist."] unless
FileTest.exists?(fname)
@error[ArgumentError, "File #{fname} isn't a file."] unless
FileTest.file?(fname)
@error[ArgumentError, "File #{fname} isn't readable."] unless
FileTest.readable?(fname)
@add[File.open(fname).singleton_def(:unlink) {self.close}]
end
def handle.each_path_with_index(&block)
if block.nil? then
@done
@error[ArgumentError, 'Block not given for Plot # data #
handle.each_path_with_index. A block is required']
end
@enum[block, true]
end
def handle.each_path(&block)
if block.nil? then
@done
@error[ArgumentError, 'Block not given for Plot # data #
handle.each_path. A block is required']
end
@enum[block, false]
end
yield handle
files.each {|f| f.unlink}
files.clear
nil
end
end
#------------------------------------------------------------#
#--- ext/singleton_class ---#
class Object
def singleton_class
class << self
self
end
end
def singleton_def(sym, &block)
self.singleton_class.send(:define_method, sym, &block)
self
end
end
--
There's no word in the English language for what you do to a dead
thing to make it stop chasing you.
