rserve-client 0.1.6 → 0.1.7

data/Examples.txt

@@ -0,0 +1,48 @@
+= Examples for Rserve
+
+<em>Based on original Java version [http://www.rforge.net/Rserve/example.html]</em>
+
+Rserve itself is provided as a regular R package and can be installed as such. The actual use is not performed by the library command, but by starting the Rserve executable (Windows) or typing R CMD Rserve on the command line (all others). By default Rserve runs in local mode with no enforced authentication. Once the Rserve is running any applications can use its services.
+
+We will show examples using the Ruby client for Rserve. The principles are identical when using other Rserve clients. Before plunging into real examples, let us consider the minimal ``hello world'' example:
+
+  require 'rserve'
+  include Rserve
+  c = Connection.new
+  x = c.eval("R.version.string");
+  puts x.as_string
+
+The code has the same effect as typing R.version.string in R. In the first line a connection to the local Rserve is established. Then the R command is evaluated and the result stored in a special object of the class REXP. This class encapsulates any objects received or sent to Rserve. If the type of the returned objects is known in advance, accessor methods can be called to obtain the Ruby object corresponding to the R value, in our case a regular String. Finally this string is printed on the standard output.
+
+The following code fragment illustrates the use of slightly more complex native Ruby types:
+
+  d = c.eval("rnorm(100)").as_doubles
+
+
+The single line in Ruby provides an array of 100 doubles representing random numbers from the standard normal distribution. The numeric vector in R is automatically converted into an array of floats. In cases where no native Ruby type exists, Rserve Ruby client defines its own classes such as Rlist or Logical (Ruby's boolean type has no support for NA missing values, therefore it cannot be used to directly represent logical type in R). This approach makes the use of Rserve very easy. As a first more practical example we want to calculate a Lowess smoother through a given set of points. The Ruby application lets the user specify the data allowing interactive changes of the points, displays a regular scatter plot and needs coordinates of the smoother to be obtained from R. One way of obtaining such a result would be to construct a long string command of the form lowes(c(0.2,0.4,...), c(2.5,4.8,...)) and using the eval method to obtain the result. This is somewhat clumsy, because the points usually already exist in an array in the Ruby application and the command string must be constructed from these. An alternative involves constructing objects in R directly. The following code shows the full Lowess example:
+
+    require 'rserve'
+    
+    data_x=Rserve::REXP::Wrapper.wrap(10.times.map{|i| rand(i)})
+    data_y=Rserve::REXP::Wrapper.wrap(10.times.map{|i| rand(i)})
+    c = Rserve::Connection.new();
+    c.assign("x", data_x);
+    c.assign("y", data_y);
+    l = c.eval("lowess(x,y)").as_list
+    lx = l.at("x").as_floats
+    ly = l.at("y").as_floats
+
+First the Ruby application defines the arrays for the data points data_x and data_y. The application is responsible for filling these arrays with the desired content (in this case, random data). Then we assign the contents of these arrays to R variables x and y. The assign command transfers the contents in binary form to Rserve and assigns this content to the specified symbol. This is far more efficient than constructing a string representation of the content.
+
+Once the variables are set in R we are ready to use the lowess function. It returns a list consisting of two vectors x and y which contain the smoother points. The Rlist object provides the method at for extraction of named entries of a list. Since lists may contain entries of different types, the object returned by the at method is of the class REXP whose content can be cast into floats in our case. The result can now be used by the Ruby application.
+
+More complex computations can be performed even without transmission of resulting objects. This is useful when defining functions or constructing complex models. Model objects are usually large, because they contain original data points, residuals and other meta data. Although they can be transferred to the client, it is more efficient to retain such objects in R and extract relevant information only. This can be done by using the void_eval method which does not transfer the result of the evaluation back to the client:
+
+  c.assign(y, ...) ...
+  c.void_eval("m<-lm(y~a+b+c)");
+  coeff = c.eval("coefficients(m)").as_floats
+
+In the above example a linear model is fitted, but its content is not passed back to the client. It is stored in an object in R for later use. Finally the coefficients are extracted from the model and passed back to the Ruby application.
+
+So far we used Rserve in local mode only. Extension to remote Rserve connections is possible without code changes, except for additional parameters to the Rserve::Connection constructor, specifying the remote computer running the \Rs. For details about the use of remote authentication, error handling and file transfer, consult the source code documentation.
+

data/History.txt

@@ -1,3 +1,11 @@
+=== 0.1.7 / 2010-05-28
+
+* Reimplement Rlist as an Array with module WithNames included
+* Added modules WithAttributes and WithNames
+* Added examples of use
+
+
+
 === 0.1.6 / 2010-05-27
 * Assign complete for all commons REXPs
 * Added Connection#shutdown

data/Manifest.txt

@@ -1,9 +1,12 @@
 .autotest
 .gitignore
+Examples.txt
 History.txt
 Manifest.txt
 README.txt
 Rakefile
+examples/hello_world.rb
+examples/lowless.rb
 lib/rserve.rb
 lib/rserve/connection.rb
 lib/rserve/engine.rb
@@ -32,6 +35,8 @@ lib/rserve/rexp/wrapper.rb
 lib/rserve/rfactor.rb
 lib/rserve/rlist.rb
 lib/rserve/talk.rb
+lib/rserve/withattributes.rb
+lib/rserve/withnames.rb
 spec/rserve_connection_spec.rb
 spec/rserve_double_spec.rb
 spec/rserve_integer_spec.rb
@@ -45,5 +50,6 @@ spec/rserve_rfactor_spec.rb
 spec/rserve_rlist_spec.rb
 spec/rserve_spec.rb
 spec/rserve_talk_spec.rb
+spec/rserve_withnames_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/Rakefile

@@ -9,6 +9,7 @@ Hoe.spec 'rserve-client' do
    self.test_globs="spec/*_spec.rb"
    self.version=Rserve::VERSION
    self.rubyforge_name = 'ruby-statsample' # if different than 'rserve'
+   self.remote_rdoc_dir = "rserve-client"
    self.developer('Claudio Bustos', 'clbustos_AT_gmail.com')
 end
 

data/examples/hello_world.rb

@@ -0,0 +1,8 @@
+require 'rserve'
+include Rserve
+c = Connection.new
+x = c.eval("R.version.string");
+puts x.as_string
+
+
+d = c.eval("rnorm(100)").as_doubles

data/examples/lowless.rb

@@ -0,0 +1,10 @@
+require 'rserve'
+
+data_x=Rserve::REXP::Wrapper.wrap(10.times.map{|i| rand(i)})
+data_y=Rserve::REXP::Wrapper.wrap(10.times.map{|i| rand(i)})
+c = Rserve::Connection.new();
+c.assign("x", data_x);
+c.assign("y", data_y);
+l = c.eval("lowess(x,y)").as_list
+lx = l.at("x").as_floats
+ly = l.at("y").as_floats

data/lib/rserve.rb

@@ -1,10 +1,14 @@
 require 'socket'
 
 module Rserve
-  VERSION = '0.1.6'
+  VERSION = '0.1.7'
 end
 
 
+require 'rserve/withnames'
+require 'rserve/withattributes'
+
+
 require 'rserve/protocol'
 require 'rserve/packet'
 require 'rserve/talk'
@@ -14,3 +18,4 @@ require 'rserve/connection'
 require 'rserve/rlist'
 require 'rserve/rfactor'
 
+

data/lib/rserve/protocol/rexpfactory.rb

@@ -236,8 +236,8 @@ module Rserve
 
           # hack for factors
           if (!get_attr.nil?)
-            ca = get_attr().as_list().at("class");
-            ls = get_attr().as_list().at("levels");
+            ca = get_attr().as_list["class"]
+            ls = get_attr().as_list["levels"]
             if (!ca.nil? and !ls.nil? and  ca.as_string=="factor")
               # R uses 1-based index, Java (and Ruby) uses 0-based one
               @cont = REXP::Factor.new(d, ls.as_strings(), get_attr)
@@ -275,8 +275,7 @@ module Rserve
               name=nf.cont.as_string if(nf.cont.symbol? or nf.cont.string?)
             end
             if name.nil?
-
-              l.add(lc.cont)
+              l.push(lc.cont)
             else
               l.put(name,lc.cont)
             end

data/lib/rserve/rexp.rb

@@ -81,7 +81,9 @@ module Rserve
     def as_doubles; raise MismatchException,"double";end;
     
     # On Ruby, Float are stored in double precision
-    alias :as_floats :as_doubles
+    def as_floats
+      as_doubles
+    end
     
     # returns the contents as an array of bytes (if supported by the represented object)
     def as_bytes; raise MismatchException , "byte";end;
@@ -115,8 +117,9 @@ module Rserve
     def as_double
     as_doubles[0]
     end
-    
-    alias  :as_float :as_double
+    def as_float
+      as_double
+    end
     # convenience method corresponding to <code>asStrings()[0]</code>
     # @return first entry returned by {@link #asStrings}
     def as_string
@@ -147,8 +150,8 @@ module Rserve
     #  @return an array of integers with corresponding dimensions or <code>null</code> if the object has no dimension attribute
     def dim
     begin
-    return has_attribute?("dim") ? @attr.as_list['dim'].as_integers :  nil;
-    rescue MismatchException
+      return has_attribute?("dim") ? @attr.as_list['dim'].as_integers :  nil;
+      rescue MismatchException
     # nothing to do
     end
     nil
@@ -158,7 +161,7 @@ module Rserve
     # @param klass class name
     # @return <code>true</code> if this object is of the class <code>klass</code>, <code>false</code> otherwise
     def inherits?(klass)
-    return false if (!has_attribute? "class")
+      return false if (!has_attribute? "class")
     begin
     c = get_attribute("class").as_strings;
     if (!c.nil?)
@@ -227,35 +230,35 @@ module Rserve
     def to_ruby
     raise "You should implement this!"
     end
-    end
-    end
-    
-    
-    require 'rserve/rexp/environment'
-    require 'rserve/rexp/null'
-    require 'rserve/rexp/unknown'
-    
-    
-    require 'rserve/rexp/vector'
-    
-    require 'rserve/rexp/raw'
-    require 'rserve/rexp/symbol'
-    require 'rserve/rexp/string'
-    require 'rserve/rexp/double'
-    require 'rserve/rexp/integer'
-    require 'rserve/rexp/logical'
-    
-    require 'rserve/rexp/factor'
+  end
+end
     
-    require 'rserve/rexp/genericvector'
-    require 'rserve/rexp/expressionvector'
     
-    
-    require 'rserve/rexp/list'
-    require 'rserve/rexp/language'
-    require 'rserve/rexp/s4'
-    
-    require 'rserve/rexp/reference'
-    
-    require 'rserve/rexp/wrapper'
+require 'rserve/rexp/environment'
+require 'rserve/rexp/null'
+require 'rserve/rexp/unknown'
+
+
+require 'rserve/rexp/vector'
+
+require 'rserve/rexp/raw'
+require 'rserve/rexp/symbol'
+require 'rserve/rexp/string'
+require 'rserve/rexp/double'
+require 'rserve/rexp/integer'
+require 'rserve/rexp/logical'
+
+require 'rserve/rexp/factor'
+
+require 'rserve/rexp/genericvector'
+require 'rserve/rexp/expressionvector'
+
+
+require 'rserve/rexp/list'
+require 'rserve/rexp/language'
+require 'rserve/rexp/s4'
+
+require 'rserve/rexp/reference'
+
+require 'rserve/rexp/wrapper'
 

data/lib/rserve/rlist.rb

@@ -1,150 +1,55 @@
 module Rserve
-  class Rlist
-    include Enumerable
-    attr_reader :names
+  class Rlist < Array
+    include WithNames
     attr_reader :data
-    def initialize(data=nil,n=nil)
+    def initialize(data=nil, n=nil)
       @names=nil
-      @data=[]
-      if data
-        @data=case data
-      when Array
-        data
-      when Numeric
-        Array.new(data)
+      if data.nil?
+        super()
       else
-        raise ArgumentError
+        case data
+        when Array
+          super(data)
+        when Numeric
+          super([data])
+        else
+          raise ArgumentError
+        end
       end
-    end
+      
     if n
-      @names=Array.new(@data.size)
+      @names=Array.new(size)
       n.each_index {|i| @names[i]=n[i]} if n.respond_to? :each_index
     end
   end
-  def named?
-    !@names.nil?
-  end
-  def ==(o)
-    #p "Comparing #{self.inspect} with #{o.inspect} gives #{o.is_a? Rlist and self.data==o.data and self.names==o.names}"
-    o.is_a? Rlist and self.data==o.data and self.names==o.names
-  end
-  # Return element with name x or 0-index x
-  def [](v)
-    if v.is_a? String
-      return nil if @names.nil? or v==""
-      i=@names.index(v)
-      return i.nil? ? nil : @data[i]
-    elsif v.is_a? Integer
-      return @data[v]
-    else
-      raise ArgumentError,"Should be String or Integer"
-    end
-  end
-
-  def at(v)
-    self.[](v)
-  end
-
-  def key_at(v)
-    return nil if @names.nil?
-    @names[v]
-  end
-  def size
-    @data.size
-  end
-
-  def each
-    @data.each do |v|
-      yield v
-    end
-  end
-
-  def set_key_at(i,value)
-    if @names.nil?
-      @names=Array.new
-    end
-    if @names.size<size
-      (size-@names.size).times {@names.push(nil)}
-    end
-
-    @names[i]=value if i < size
-
-  end
-
   def keys
     @names
   end
-
-  def put(key,value)
-    puts "rlist.put(#{key},#{value})" if $DEBUG
-    if key.nil?
-      add(value)
-      return nil
-    end
-    if !@names.nil?
-      p=names.index(key)
-      if !p.nil?
-        return @names[p]=value
-      end
-    end
-    puts "add key and value" if $DEBUG
-    i=size
-    @names=Array.new(i) if(@names.nil?)
-    @data.push(value)
-    @names.push(key)
-
-  end
-  def add(a,b=nil)
-    if b.nil?
-      @data.push(a)
-      @names=Array.new(@data.size-1) if @names.nil?
-      @names.push(nil)
-    else
-      @data.insert(a,b)
-      @names.insert(a,nil)
-    end
-  end
-  def clear
-    @data.clear
-    @names=nil
+  # Returns the data without names, as Ruby objects
+  def to_a
+    self.map {|d| d.to_ruby} 
   end
-  def clone
-    RList.new(@data,@names)
+  # Returns the data, as REXP
+  def data
+    self.map {|d| d}
   end
-  def remove(elem)
-    if elem.is_a? String
-      i=@data.index(elem)
-    elsif elem.is_a? Integer
-      i=elem
-    end
-    return false if i.nil?
-    @data.delete_at(i)
-    @names.delete_at(i) unless @names.nil?
-    @names=nil if size==0
-  end
-  # Returns data with appropiate ruby representation
-  def to_a
-    @data.map {|d|
-      d.to_ruby
-    }
+  def ==(o)
+    #p "Comparing #{self.inspect} with #{o.inspect} gives #{o.is_a? Rlist and self.data==o.data and self.names==o.names}"
+    o.is_a? Rlist and self.data==o.data and self.names==o.names
   end
-  # Returns recursively a hash or array:
+
+  
+  # Returns an Array with module WithNames included
   # * Unnamed list: returns an Array
   # * Named List: returns a Hash. Every element without explicit name receive
   #   as key the number of element, 1-based
   #
 
   def to_ruby
-    if names.nil? or names.all? {|v| v.nil?}
-      to_a
-    else
-      h=Hash.new
-      names.each_with_index {|name,i|
-        key= (name=="" or name.nil?) ? i+1 : name
-        h[key]=@data[i].to_ruby
-      }
-      h
-    end
+    data=to_a
+    data.extend WithNames
+    data.names=@names
+    data
   end
 end
 end

data/lib/rserve/withattributes.rb

@@ -0,0 +1,5 @@
+module Rserve
+  module WithAttributes
+    attr_accessor :attributes
+  end
+end

data/lib/rserve/withnames.rb

@@ -0,0 +1,109 @@
+module Rserve
+  # Provides names to elements on an Array
+  module WithNames
+    attr_reader :names
+    def names=(v)
+      raise ArgumentError, "#size should be equal to object size" if !v.nil? and v.size!=self.size
+      raise ArgumentError, "element must be String or nil" unless v.nil? or v.all? {|v1| v1.nil? or v1.is_a? String}
+      @names=v
+    end
+    def push(v,name=nil)
+      @names||=Array.new(self.size)
+      (@names.size-self.size).times { @names.push(nil)}
+      @names.push(name)
+      super(v)
+    end
+    def inspect
+      "#<#{self.class}:#{self.object_id} #{super} names:#{@names.inspect}>"
+    end
+    def clear
+      @names=nil
+      super()
+    end
+    def delete_at(i)
+      unless @names.nil?
+        @names.delete_at(i)
+      end
+      super(i)
+    end
+    def pop
+      unless @names.nil?
+        @names.pop
+      end
+      super
+    end
+ 
+    def reverse!
+      unless @names.nil?
+        @names.reverse!
+      end
+      super
+    end
+    def shift
+      unless @names.nil?
+        @names.shift
+      end
+      super  
+    end
+    def slice(*args)
+      sliced=super(*args)
+      unless @names.nil?
+        sliced.extend Rserve::WithNames
+        sliced.names=@names.slice(*args)
+      end
+      sliced
+    end
+    def named?
+      !@names.nil?
+    end
+    def to_a
+      Array.new(self)
+    end
+    def key_at(v)
+      @names.nil? ?  nil : @names[v]
+    end
+    # Put a value on specific key
+    # If key exists, replaces element of apropiate index
+    # If key doesn't exists, works as push(value,key)
+    def put(key,value)
+      if key.nil?
+        add(value)
+        return nil
+      end
+      
+      if !@names.nil?
+        pos=@names.index(key)
+        if !pos.nil?
+          return @names[pos]=value
+        end
+      end      
+      push(value,key)      
+    end
+    def __add(a,b=nil)
+      if b.nil?
+        @data.push(a)
+        @names=Array.new(@data.size-1) if @names.nil?
+        @names.push(nil)
+      else
+        @data.insert(a,b)
+        @names.insert(a,nil)
+      end
+    end
+    def [](v)
+      case v
+      when Integer
+          at(v)
+        when Array
+          raise "You must use something like v[[1]]" if v.size!=1 or !v[0].is_a? Integer
+          at(v[0]-1)
+        when String
+          if !@names.nil?
+            i=@names.index(v)
+            i.nil? ? nil : at(i)
+          else
+            nil
+         end
+      end
+    end
+  end
+end

data/spec/rserve_rlist_spec.rb

@@ -32,21 +32,21 @@ describe Rserve::Rlist do
   it "method to_a return an array with best ruby representation of data" do
     @l.to_a.should==['Fred',30,10,20,[1,2,3]]
   end
-  it "method to_ruby returns a hash when all names are set" do
+  it "method to_ruby returns a named array when all names are set" do
     list=@r.eval("list(name='Fred', age=30)")
-    list.to_ruby.should=={'name'=>'Fred','age'=>30}
+    a=['Fred',30]
+    a.extend Rserve::WithNames
+    a.names=['name','age']
+    list.to_ruby.should==a
   end
-  it "method to_ruby returns a hash with numbers (1-based) replacing empty names" do
-    list=@r.eval("list(name='Fred', age=30,'aaaa')")
-    list.to_ruby.should=={'name'=>'Fred','age'=>30,3=>'aaaa'}
-  end
-  it "method to_ruby returns an array when no names are set" do
+  it "method to_ruby returns a simple array when no names are set" do
     list=@r.eval("list(10,20,30)")
     list.to_ruby.should==[10,20,30]
   end
   it "should allow recursive list" do
     list=@r.eval("list(l1=list(l11=1,l22=2),l2=list(3,4))").as_list
-    list['l1'].to_ruby.should=={'l11'=>1,'l22'=>2}
+    list.names.should==['l1','l2']
+    list['l1'].to_ruby.should==[1,2]
     list['l2'].to_ruby.should==[3,4]
 
   end

data/spec/rserve_withnames_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__)+"/spec_helper.rb"
+
+describe Rserve::WithNames do
+  before do
+    @a=[1,2,3,4]
+    @a.extend Rserve::WithNames
+  end
+    it "should return nil without names" do
+      @a.names.should be_nil
+    end
+  describe "with incorrect naming" do
+    it "should raise an error with names array of another size" do
+      lambda {@a.names=["1","2"]}.should raise_exception
+    end
+    it "should raise an error with names array !(String or nil)  " do
+      lambda {@a.names=[1,"a","b","c"]}.should raise_exception
+      lambda {@a.names=[nil,"a","b","c"]}.should_not raise_exception
+    end
+  end
+  describe "correct naming" do
+    before do
+      @a.names=['a','b','c',nil]
+    end
+    it "should set names and return them without problems" do
+      @a.names.should==['a','b','c',nil] 
+    end
+    it "should return correct values with 0-index([x])" do
+      @a[0].should==1
+      @a[3].should==4
+    end
+    it "should return correct values with 1-index syntactic sugar ([[x]])" do
+      @a[[1]].should==1
+      @a[[4]].should==4
+    end
+    it "should return with names(['x'])" do
+      @a['a'].should==1
+      @a['b'].should==2
+    end
+    it "should push with or without name" do
+      @a.push(5)
+      @a.names.should==['a','b','c',nil,nil]
+      @a.push(6,'f')
+      @a.names.should==['a','b','c',nil,nil,'f']
+    end
+    it "method clear should delete names" do
+      @a.clear
+      @a.names.should be_nil
+    end
+    it "should delete_at names" do
+      @a.delete_at(0)
+      @a.should==[2,3,4]
+      @a.names.should==["b","c",nil]
+    end
+    it "should pop names" do
+      @a.pop
+      @a.names.should==['a','b','c']
+    end
+    it "should shift names" do
+      @a.shift
+      @a.names.should==['b','c',nil]
+    end
+    it "should reverse! names" do
+      @a.reverse!
+      @a.names.should==[nil,'c','b','a']
+    end
+    it "should slice names" do
+      b=@a.slice(1,2)
+      b.should==[2,3]
+      b.names.should==['b','c']
+    end
+  end  
+  
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 6
-  version: 0.1.6
+  - 7
+  version: 0.1.7
 platform: ruby
 authors: 
 - Claudio Bustos
@@ -35,7 +35,7 @@ cert_chain:
   rpP0jjs0
   -----END CERTIFICATE-----
 
-date: 2010-05-27 00:00:00 -04:00
+date: 2010-05-28 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -77,16 +77,20 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
+- Examples.txt
 - History.txt
 - Manifest.txt
 - README.txt
 files: 
 - .autotest
 - .gitignore
+- Examples.txt
 - History.txt
 - Manifest.txt
 - README.txt
 - Rakefile
+- examples/hello_world.rb
+- examples/lowless.rb
 - lib/rserve.rb
 - lib/rserve/connection.rb
 - lib/rserve/engine.rb
@@ -115,6 +119,8 @@ files:
 - lib/rserve/rfactor.rb
 - lib/rserve/rlist.rb
 - lib/rserve/talk.rb
+- lib/rserve/withattributes.rb
+- lib/rserve/withnames.rb
 - spec/rserve_connection_spec.rb
 - spec/rserve_double_spec.rb
 - spec/rserve_integer_spec.rb
@@ -128,6 +134,7 @@ files:
 - spec/rserve_rlist_spec.rb
 - spec/rserve_spec.rb
 - spec/rserve_talk_spec.rb
+- spec/rserve_withnames_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
@@ -167,6 +174,7 @@ test_files:
 - spec/rserve_rfactor_spec.rb
 - spec/rserve_connection_spec.rb
 - spec/rserve_double_spec.rb
+- spec/rserve_withnames_spec.rb
 - spec/rserve_packet_spec.rb
 - spec/rserve_rexpfactory_spec.rb
 - spec/rserve_rexp_spec.rb