simpler ("Simple R") is a lightweight wrapper of R (really Rscript) inspired by the gnuplot and rsruby gems.
Ruby
Switch branches/tags
Nothing to show
Latest commit d35a208 Oct 22, 2013 @jtprince jtprince Merge branch 'master' of github.com:jtprince/simpler
Trying to merge
Permalink
Failed to load latest commit information.
lib not sure Oct 22, 2013
spec merged Ryans ruby 1.8 fixes and brushed up specs Jan 3, 2011
.document Initial commit to simpler. Jun 25, 2010
.gitignore release 0.1.0 Aug 3, 2010
History warning Jul 9, 2010
LICENSE Initial commit to simpler. Jun 25, 2010
README.rdoc not sure Oct 22, 2013
Rakefile release 0.1.0 Aug 3, 2010
VERSION Version bump to 0.1.0 Aug 3, 2010

README.rdoc

simpler

simpler (“simple R”) is a lightweight wrapper that calls R (really Rscript) from within ruby. It is designed to favor R in syntax.

This is still very pre-alpha and the interface is subject to change.

RSRuby, RinRuby, or Simpler?

You should probably take a look at rsruby–it's a fantastic gem. Embedding R, rather than calling out to R can make calls 10X faster (according to Ryan Davis). Plus, if you need to evaluate R code with rsruby, you can use this kind of call:

RSRuby.instance.eval_R r_src

However, if you want to work with a system designed for using native R code, or if you can't get rsruby compiling properly, RinRuby or Simpler may be useful to you.

RinRuby has the same design goals as Simpler and is much more thorough in its implementation and execution. You should definitely take a look at RinRuby.

Simpler is very simple code that uses Rscript (R's scripting command) to plot R code. If a robust, minimalist approach appeals to you, maybe simpler is for you. I like to use it when I'm not using RSRuby or RinRuby.

Examples

(the API is still unstable)

Basic execution (Raw input, raw output)

require 'simpler'

r = Simpler.new
r >> "mean(c(1,2,3))"   # -> "[1] 2\n"  (a Simpler::Reply object)

Using ruby variables (calculating correlation coefficient):

x = [1,2,7]
y = [3,4,8]
# variables are given a symbol name
reply = r.eval!(x => :xr, y => :yr) { "cor(xr,yr)" }   # -> "[1] 0.9994238\n"
# the naming can be in any order, so in ruby > 1.9, this is valid:
reply = r.eval!(xr: x, yr: y) { "cor(xr,yr)" }

Any object that has a to_r method can be passed in. Currently, Array and Simpler::DataFrame are the only objects with this method defined, but that actually covers a lot of ground. Easy to define your own to_r method for special data as needed.

Show a plot

Simpler uses Rscript to run R commands. So, all plots that would normally go to X11 are saved to “Rplots.pdf”. show! is precisly the same as eval!, but it also opens “Rplots.pdf” with @pdf_viewer:

r.pdf_viewer = "acroread"
r.show!(x,y) {|xr,yr| "plot(#{xr}, #{yr})" }

Using DataFrames

hash = {
  :one => [1,2,6,7],
  :two => [3,4,2,9],
  :three => [3,1,1,7],
}

df = Simpler::DataFrame.new(hash)
r.show!(df => :dfr) { "plot(dfr)" }

One can also make a data frame from an array of structs with Simpler::DataFrame.from_structs

When Errors Arise

On an R error, raises a Simpler::RError that returns the R error message and shows the R code submitted. (the @command queue is still cleared)

# this will raise a descriptive Simpler::RError error
r.eval! { "plot(c(1,2,3),c(1,2))" }

Credit

Simpler is loosely inspired by the original gnuplot and, of course, the excellent rsruby. I ran into RinRuby after writing Simpler: I probably wouldn't have written Simpler had I seen it first, but since it is here and since it has a slightly different design and implementation I will continue to support it.

Casting

All replies are of class Simpler::Reply (a string subclass), so casting can be done in a way that works for you by defining your own methods.

Copyright

Copyright © 2010 John Prince. See LICENSE for details.