rserve-client 0.1.9 → 0.2.0

data/History.txt

@@ -1,5 +1,13 @@
-=== 0.1.9 / 2010-06-04
+=== 0.2.0 / 2010-06-15
+* Session implemented. 
+* Retrieve auth information from server first responde. TODO: Implement authentification
+* Rserve::Protocol get_int and get_long uses pack. Spec for test compatibility for old method 
+* Added benchmark, comparing Rserve with RinRuby and RsRuby
+* Windows Support:
+ * On windows, any new connection closes the previous. Rserve on Windows can't process parallel connections
+ * All Specification works on Windows
 
+=== 0.1.9 / 2010-06-04
 * Documentation:
  * Added commentaries on examples/regression.txt
  * Examples.txt on main directory renamed to Introduction.txt

data/Manifest.txt

@@ -4,6 +4,10 @@ Introduction.txt
 Manifest.txt
 README.txt
 Rakefile
+benchmark/benchmark.rb
+benchmark/comparison_2010_06_07.xls
+benchmark/comparison_2010_06_07_using_pack.xls
+benchmark/plot.rb
 data/gettysburg.txt
 examples/gettysburg.rb
 examples/hello_world.rb
@@ -36,9 +40,11 @@ lib/rserve/rexp/vector.rb
 lib/rserve/rexp/wrapper.rb
 lib/rserve/rfactor.rb
 lib/rserve/rlist.rb
+lib/rserve/session.rb
 lib/rserve/talk.rb
 lib/rserve/withattributes.rb
 lib/rserve/withnames.rb
+spec/rserve_connection_on_unix_spec.rb
 spec/rserve_connection_spec.rb
 spec/rserve_double_spec.rb
 spec/rserve_genericvector_spec.rb
@@ -52,6 +58,7 @@ spec/rserve_rexp_wrapper_spec.rb
 spec/rserve_rexpfactory_spec.rb
 spec/rserve_rfactor_spec.rb
 spec/rserve_rlist_spec.rb
+spec/rserve_session_spec.rb
 spec/rserve_spec.rb
 spec/rserve_talk_spec.rb
 spec/rserve_withnames_spec.rb

data/README.txt

@@ -16,10 +16,11 @@ Follows closely the new Java client API, but maintains all Ruby conventions when
 * Requires Rserve installed on the server machine. On debian /  ubuntu, you should use <tt>sudo apt-get install r-cran-rserve</tt>
 Pros:
   * Work with Ruby 1.8, 1.9 and JRuby 1.5.
-  * Should work on Windows (not tested yet)
-  * Implements almost completely R's datatypes: integer, doubles, chars, logical vectors, lists and raw data.
-  * Follows closely the Java API, so any change on the server API could be adopted without much problem
-  * Fast
+  * Work on Windows. Rserve limitations on that plataform applies (single connection, crash on parse errors)
+  * Retrieve and assign various R's datatypes: integer, doubles, chars, logical vectors, lists and raw data.
+  * Session allows to process data asynchronously. You start a command, detach the process and retrieve result later. You can marshall the session, store on file or database and use it when you need it.
+  * Ruby API follows closely the Java API, so any change on the server API could be adopted without much problem
+  * Fast: 5-10 times faster than RinRuby.
   * Easy management of differences between R and Ruby, or "You can have your cake and eat it, too!"
     *  From R side: The evaluation of expression retrieves REXP object, with a lot of information from original variables on R. You can construct your REXP objects and <tt>assign</tt> them to variables on R fast using binary TCP/IP port or send complex expression without lost of time using <tt>void_eval</tt> 
     * Between R and Ruby: Every REXP object implements methods to convert to specific Ruby type: as_integers, as_doubles, as_strings
@@ -38,16 +39,17 @@ Cons:
     * Work with Ruby 1.8, 1.9 and JRuby 1.5
     * All API tested
   * Cons:
-    * VERY SLOW
+    * VERY SLOW on assignation
     * Very limited datatypes: Only vector and Matrix
 * RSRuby
   * C Extension for Ruby, linked to R's shared library
   * Pros:
-    * Very fast data access
+    * Blazing speed! 5-10 times faster than Rserve and 100-1000 than RinRuby.
     * Seamless integration with ruby. Every method and object is treated like a Ruby one
   * Cons:
     * Transformation between R and Ruby types aren't trivial
     * Dependent on operating system, Ruby implementation and R version
+    * Ocassionaly crash
     * Not available for alternative implementations of Ruby (JRuby, IronRuby and Rubinius)
     
     
@@ -55,7 +57,6 @@ Cons:
 
 Implements
 
-* Sessions
 * Authentification
 * Original test
 

data/benchmark/benchmark.rb

@@ -0,0 +1,113 @@
+# Compares rserve, rinruby and rsruby
+# in retrieval and assign of information
+$:.unshift(File.dirname(__FILE__)+"/../lib")
+
+require 'rubygems'
+require 'rserve'
+require 'rinruby'
+begin 
+require 'rsruby'
+rs=RSRuby.instance
+rescue LoadError
+rs=nil
+end
+require 'benchmark'
+data_size=30000
+tries=50
+con=Rserve::Connection.new
+R.eval("1",false)
+data=data_size.times.map {rand()}
+data_integer=data_size.times.map {rand(100)}
+Benchmark.bm(30) do |x|
+  x.report("assign '1' rinruby") {
+    tries.times {
+      R.a=1
+    }
+  }
+  x.report("assign '1' rserve") {
+    con.assign("a", 1)
+  }
+  if rs
+  x.report("assign '1' rsruby") {
+    rs.assign('a',1)
+  }
+  end
+  x.report("assign double(#{data_size}) rinruby") {
+    tries.times {
+      R.a=data
+    }
+  }
+  x.report("assign double(#{data_size}) rserve") {
+    con.assign("a", data)
+  }
+  if rs
+  x.report("assign double(#{data_size}) rsruby") {
+    rs.assign("a", data)
+  }
+end
+  x.report("void_eval rinruby") {
+    tries.times {
+      R.eval("1",false)
+    }
+  }
+  x.report("void_eval rserve") {
+    tries.times {
+      con.void_eval("1")
+    }
+  }
+  if rs
+  x.report("void_eval rsruby") {
+    tries.times {
+      rs.eval("1")
+    }
+  }
+  end
+  # Assign data
+  R.a=1
+  con.assign('a',1)
+  if rs
+  rs.assign('a',1)
+  end
+  x.report("get '1' rinruby") {
+    tries.times {
+      R.pull('a')
+    }
+  }
+  x.report("get '1' rserve") {
+    tries.times {
+      con.eval('a').to_ruby
+    }
+  }
+  if rs
+  x.report("get '1' rsruby") {
+    tries.times {
+      rs.a
+    }
+  }
+end
+  
+  R.a=data
+  con.assign('a',data)
+  if rs
+  rs.assign('a',data)
+  end
+  x.report("get double(#{data_size}) rinruby") {
+    tries.times {
+      R.pull('a')
+    }
+  }
+  x.report("get double(#{data_size}) rserve") {
+    tries.times {
+      con.eval('a').to_ruby
+    }
+  }
+  
+  if rs
+  x.report("get double(#{data_size}) rsruby") {
+    tries.times {
+      rs.a
+    }
+  }
+  end
+
+end

data/benchmark/plot.rb

@@ -0,0 +1,69 @@
+# Creates a graph with multiple size assignment and retrieval
+
+require 'rubygems'
+require 'rserve'
+require 'rinruby'
+require 'benchmark'
+require 'statsample'
+require 'rsruby'
+
+max=45
+R.eval("1")
+rs=RSRuby.instance
+con=Rserve::Connection.new
+rserve_assign    = []
+rserve_retrieve  = []
+rinruby_assign   = []
+rinruby_retrieve = []
+rs_assign=[]
+rs_retrieve=[]
+
+max.times.map {|x|
+  puts "Rserve #{x}"
+  start=Time.new.to_f
+  con.assign('a',(x*100+1).times.map {rand})
+  a=Time.new.to_f-start
+  
+  start=Time.new.to_f
+
+  con.eval('a').to_f
+  
+  b=Time.new.to_f-start
+  
+  rserve_assign.push(a)
+  rserve_retrieve.push(b)
+}
+max.times.map {|x|
+
+  puts "Rinruby #{x}"
+  start=Time.new.to_f
+  R.assign("a", (x*100+1).times.map {rand})
+  a=Time.new.to_f-start
+  start=Time.new.to_f
+  R.pull('a')
+  b=Time.new.to_f-start
+  rinruby_assign.push(a)
+  rinruby_retrieve.push(b)
+}
+
+
+max.times.map {|x|
+  puts "RsRuby #{x}"
+  start=Time.new.to_f
+  rs.assign('a',(x*100+1).times.map {rand})
+  a=Time.new.to_f-start
+  
+  start=Time.new.to_f
+
+  rs.a.to_f
+  
+  b=Time.new.to_f-start
+  
+  rs_assign.push(a)
+  rs_retrieve.push(b)
+}
+
+
+ds_assign={'times'=>(1..max).map {|v| v*100+1}.to_scale,'rserve assign'=> rserve_assign.to_scale, 'rserve retrieve'=>rserve_retrieve.to_scale, 'rinruby assign'=>rinruby_assign.to_scale, 'rinruby retrieve'=>rinruby_retrieve.to_scale, 'rs_assign'=>rs_assign.to_scale, 'rs_retrieve'=>rs_retrieve.to_scale}.to_dataset
+ds_assign.fields=['times','rs_assign','rserve_assign','rinruby_assign','rs_retrieve','rserve_retrieve','rinruby_retrieve']
+Statsample::Excel.write(ds_assign,'comparison.xls')

data/examples/hello_world.rb

@@ -5,4 +5,4 @@ x = c.eval("R.version.string");
 puts x.as_string
 
 
-d = c.eval("rnorm(100)").as_doubles
+d = c.eval("rnorm(10000)").as_doubles

data/lib/rserve.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 module Rserve
-  VERSION = '0.1.9'
+  VERSION = '0.2.0'
 end
 
 
@@ -14,6 +14,7 @@ require 'rserve/packet'
 require 'rserve/talk'
 require 'rserve/rexp'
 require 'rserve/engine'
+require 'rserve/session'
 require 'rserve/connection'
 require 'rserve/rlist'
 require 'rserve/rfactor'

data/lib/rserve/connection.rb

@@ -1,5 +1,7 @@
+require 'rbconfig'
 module Rserve
   class Connection < Rserve::Engine
+    @@connected_object=nil
     include Rserve::Protocol
 
     # :section: Exceptions
@@ -27,6 +29,7 @@ module Rserve
     attr_reader :rt
     attr_reader :s
     attr_reader :port
+    attr_reader :session
     attr_writer :transfer_charset
     attr_reader :rsrv_version
     attr_writer :persistent
@@ -40,10 +43,13 @@ module Rserve
       @hostname         = opts.delete(:hostname)          || "127.0.0.1"
       @port_number      = opts.delete(:port_number)       || 6311
       @max_tries        = opts.delete(:max_tries)         || 5
+      @session          = opts.delete(:session)           || nil
       @tries            = 0
       @connected=false
-
-
+      if (!@session.nil?)
+        @hostname=@session.host
+        @port_number=@session.port
+      end
       begin
         #puts "Tryin to connect..."
         connect
@@ -72,22 +78,49 @@ module Rserve
       end
     end
     def connect
-      
+      # On windows, Rserve doesn't allows concurrent connections. 
+      # So, we must close the last open connection first
+      if RbConfig::CONFIG['arch']=~/mswin/ and !@@connected_object.nil?
+        @@connected_object.close
+      end
+
       close if @connected
+      
       @s = TCPSocket::new(@hostname, @port_number)
       @rt=Rserve::Talk.new(@s)
-      #puts "Connected"
-      # Accept first input
-      input=@s.recv(32).unpack("a4a4a4a20")
-      raise IncorrectServer,"Handshake failed: Rsrv signature expected, but received [#{input[0]}]" unless input[0]=="Rsrv"
-      @rsrv_version=input[1].to_i
-      raise IncorrectServerVersion, "Handshake failed: The server uses more recent protocol than this client." if @rsrv_version>103
-      @protocol=input[2]
-      raise IncorrectProtocol, "Handshake failed: unsupported transfer protocol #{@protocol}, I talk only QAP1." if @protocol!="QAP1"
-      @extra=input[4]
+      if @session.nil?
+        #puts "Connected"
+        # Accept first input
+        input=@s.recv(32).unpack("a4a4a4a4a4a4a4a4")      
+        raise IncorrectServer,"Handshake failed: Rsrv signature expected, but received [#{input[0]}]" unless input[0]=="Rsrv"
+        @rsrv_version=input[1].to_i
+        raise IncorrectServerVersion, "Handshake failed: The server uses more recent protocol than this client." if @rsrv_version>103
+        @protocol=input[2]
+        raise IncorrectProtocol, "Handshake failed: unsupported transfer protocol #{@protocol}, I talk only QAP1." if @protocol!="QAP1"
+        (3..7).each do |i|
+          attr=input[i]
+          if (attr=="ARpt") 
+            if (!auth_req) # this method is only fallback when no other was specified
+              auth_req=true
+              auth_type=AT_plain
+            end
+          end
+          if (attr=="ARuc") 
+            auth_req=true
+            authType=AT_crypt
+          end
+          if (attr[0]=='K') 
+            key=attr[1,3]
+          end
+          
+        end
+      else # we have a session to take care of
+        @s.write(@session.key.pack("C*"))
+        @rsrv_version=session.rsrv_version
+      end
       @connected=true
+      @@connected_object=self
       @last_error="OK"
-
     end
     def connected?
       @connected
@@ -99,6 +132,7 @@ module Rserve
       end
       raise "Can't close socket" unless @s.closed?
       @connected=false
+      @@connected_object=nil
       true
     end
     def get_server_version
@@ -119,6 +153,20 @@ module Rserve
     end
 
 
+    def void_eval_detach(cmd)
+      raise NotConnected if !connected? or rt.nil?
+      rp=rt.request(:cmd=>Rserve::Protocol::CMD_detachedVoidEval,:cont=>cmd+"\n")
+      if rp.nil? or !rp.ok?
+        raise EvalError.new(rp), "detached void eval failed : #{rp.to_s}"
+      else
+        s=Rserve::Session.new(self,rp)
+        close
+        s
+      end
+    end
+
+
+
     # evaluates the given command and retrieves the result
     # * @param cmd command/expression string
     # * @return R-xpression or <code>null</code> if an error occured */
@@ -233,6 +281,19 @@ module Rserve
         raise "Shutdown failed"
       end
     end
-        
+    # detaches the session and closes the connection (requires Rserve 0.4+).
+    # The session can be only resumed by calling RSession.attach
+    
+    def detach
+      raise NotConnected if !connected? or rt.nil?
+      rp=rt.request(:cmd=>Rserve::Protocol::CMD_detachSession)
+      if !rp.nil? and rp.ok? 
+        s=Rserve::Session.new(self,rp)
+        close
+        s
+      else
+        raise "Cannot detach"
+      end
+    end
   end
 end

data/lib/rserve/protocol.rb

@@ -1,3 +1,4 @@
+require 'rbconfig'
 module Rserve
   #
   # This module encapsulates methods and constants related to QAP1 protocol used by Rserv. Follows almost exactly the interface on RTalk class
@@ -7,6 +8,15 @@ module Rserve
   # Policy: No other class should know about the internal of protocol!
   # See Rtalk class on Java version.
   module Protocol
+    # Arch dependent Long Nil value 
+    case Config::CONFIG['arch']
+      when 'i686-linux'
+        LONG_NA=9221120237041092514 # :nodoc:
+      when /mswin/
+	LONG_NA=9221120237041092514 # :nodoc:
+      else
+	LONG_NA=9218868437227407266 # :nodoc:
+      end
     # Defines from Rsrv.h
     CMD_RESP=0x010000 # all responses have this flag set
     RESP_OK=(CMD_RESP|0x0001) # command succeeded; returned parameters depend on the command issued
@@ -162,7 +172,9 @@ module Rserve
     # make sure that the buffer is big enough
 
     def get_int(buf, o)
-      #return buf.slice(o,4).pack("C*").unpack("l")[0]
+      buf[o,4].pack("C*").unpack("l")[0]
+    end
+    def get_int_original(buf,o) # :nodoc:
       v=((buf[o]&255)|((buf[o+1]&255)<<8)|((buf[o+2]&255)<<16)|((buf[o+3]&255)<<24))
       v >= MAX_LONG_SIGNED ? v-MAX_LONG_UNSIGNED : v
     end
@@ -187,12 +199,20 @@ module Rserve
     # @param o offset (8 bytes will be used)
     # @return long value */
     def get_long(buf, o)
+      buf[o,8].pack("CCCCCCCC").unpack("Q")[0]
+    end
+    def get_long_original(buf,o)   #:nodoc:
       low=(get_int(buf,o))&0xffffffff;
       hi=(get_int(buf,o+4))&0xffffffff;
       hi<<=32; hi|=low;
       hi
     end
+    
     def longBitsToDouble(bits)
+      (bits==LONG_NA) ? Rserve::REXP::Double::NA : [bits].pack("Q").unpack("d")[0]
+    end
+    # Complete version of longBitsToDouble, as Java documentation established 
+    def longBitsToDouble_old(bits) # :nodoc:
       s = ((bits >> 63) == 0) ? 1 : -1;
       e = ((bits >> 52) & 0x7ff)
       m = (e == 0) ?
@@ -200,6 +220,7 @@ module Rserve
       (bits & 0xfffffffffffff) | 0x10000000000000;
       s*m*2**(e-1075)
     end
+    
     def doubleToRawLongBits(double)
       [double].pack("d").unpack("Q")[0]
     end

data/lib/rserve/rexp.rb

@@ -1,8 +1,8 @@
 module Rserve
-  #  Basic class representing an object of any type in R. Each type in R in represented by a specific subclass.
-  #
-  # This class defines basic accessor methods (<tt>as</tt><i>XXX</i>), type check methods (<tt>is</tt><i>XXX</i>), gives access to attributes ({@link #getAttribute}, {@link #hasAttribute}) as well as several convenience methods. If a given method is not applicable to a particular type, it will throw the {@link MismatchException} exception.
+  #  Basic class representing an object of any type in R. Each type in R in represented by a specific subclass. 
   #
+  # This class defines basic accessor methods (<tt>as</tt>_<i>xxx</i>), type check methods (<i>XXX</i><tt>?</tt>), gives access to attributes (REXP.get_attribute, REXP.has_attribute?) as well as several convenience methods. If a given method is not applicable to a particular type, it will throw the MismatchException exception.
+  # 
   # This root class will throw on any accessor call and returns <code>false</code> for all type methods. This allows subclasses to override accessor and type methods selectively.
   #
   class REXP
@@ -16,181 +16,232 @@ module Rserve
     # specifies how many items of a vector or list will be displayed in {@link #toDebugString}
     MaxDebugItems = 32
     # :section: type checks
-    # check whether the <code>REXP</code> object is a character vector (string)
-    # @return <code>true</code> if the receiver is a character vector, <code>false</code> otherwise
-
+    
+    # check whether the <code>REXP</code> object is a character vector (string).
+    #
+    # @return [boolean] <code>true</code> if the receiver is a character vector, <code>false</code> otherwise
     def string?
       false
     end
 
-      # # check whether the <code>REXP</code> object is a numeric vector
-      # @return <code>true</code> if the receiver is a numeric vector, <code>false</code> otherwise
+    # check whether the <code>REXP</code> object is a numeric vector.
+    #
+    # @return [boolean] <code>true</code> if the receiver is a numeric vector, <code>false</code> otherwise
 
     def numeric?
       false
     end
-    # check whether the <code>REXP</code> object is an integer vector
-    # @return <code>true</code> if the receiver is an integer vector, <code>false</code> otherwise
+    # check whether the <code>REXP</code> object is an integer vector.
+    # 
+    # @return [boolean] <code>true</code> if the receiver is an integer vector, <code>false</code> otherwise
     def integer?
       false
     end
-    # check whether the <code>REXP</code> object is NULL
-    # @return <code>true</code> if the receiver is NULL, <code>false</code> otherwise
+    # check whether the <code>REXP</code> object is NULL.
+    # 
+    # @return [boolean] <code>true</code> if the receiver is NULL, <code>false</code> otherwise
     def null?
       false
     end
-    # check whether the <code>REXP</code> object is a factor
-    # @return <code>true</code> if the receiver is a factor, <code>false</code> otherwise
+    
+    # check whether the <code>REXP</code> object is a factor.
+    #
+    # @return [boolean] <code>true</code> if the receiver is a factor, <code>false</code> otherwise
     def factor?
       false
     end
-    # check whether the <code>REXP</code> object is a list (either generic vector or a pairlist - i.e. {@link #asList()} will succeed)
-    # @return <code>true</code> if the receiver is a generic vector or a pair-list, <code>false</code> otherwise
+    
+    # check whether the <code>REXP</code> object is a list (either generic vector or a pairlist - i.e. REXP.asList() will succeed).
+    #
+    # @return [boolean] <code>true</code> if the receiver is a generic vector or a pair-list, <code>false</code> otherwise
     def list?
       false
     end
-    # check whether the <code>REXP</code> object is a pair-list
-    # @return <code>true</code> if the receiver is a pair-list, <code>false</code> otherwise
+    # check whether the <code>REXP</code> object is a pair-list.
+    #
+    # @return [boolean] <code>true</code> if the receiver is a pair-list, <code>false</code> otherwise
     def pair_list?
       false
     end
-    # check whether the <code>REXP</code> object is a logical vector
-    # @return <code>true</code> if the receiver is a logical vector, <code>false</code> otherwise */
+    # check whether the <code>REXP</code> object is a logical vector.
+    #
+    # @return [boolean] <code>true</code> if the receiver is a logical vector, <code>false</code> otherwise */
     def logical?
       false
     end
-    #  check whether the <code>REXP</code> object is an environment
-    # @return <code>true</code> if the receiver is an environment, <code>false</code> otherwise
+    # check whether the <code>REXP</code> object is an environment.
+    # 
+    # @return [boolean] <code>true</code> if the receiver is an environment, <code>false</code> otherwise
     def environment?
       false
     end
-    # check whether the <code>REXP</code> object is a language object
-    # @return <code>true</code> if the receiver is a language object, <code>false</code> otherwise
+    # check whether the <code>REXP</code> object is a language object.
+    # 
+    # @return [boolean] <code>true</code> if the receiver is a language object, <code>false</code> otherwise
     def language?
       false
     end
-    # check whether the <code>REXP</code> object is an expression vector
-    # @return <code>true</code> if the receiver is an expression vector, <code>false</code> otherwise
+    # check whether the <code>REXP</code> object is an expression vector.
+    # 
+    # @return [boolean] <code>true</code> if the receiver is an expression vector, <code>false</code> otherwise
     def expression?
       false
     end
-    # check whether the <code>REXP</code> object is a symbol
-    # @return <code>true</code> if the receiver is a symbol, <code>false</code> otherwise
+    # check whether the <code>REXP</code> object is a symbol.
+    # 
+    # @return [boolean] <code>true</code> if the receiver is a symbol, <code>false</code> otherwise
     def symbol?
       false
     end
-    # check whether the <code>REXP</code> object is a vector
-    # @return <code>true</code> if the receiver is a vector, <code>false</code> otherwise
+    # check whether the <code>REXP</code> object is a vector.
+    #
+    # @return [boolean] <code>true</code> if the receiver is a vector, <code>false</code> otherwise
     def vector?
       false
     end
     # check whether the <code>REXP</code> object is a raw vector
-    # @return <code>true</code> if the receiver is a raw vector, <code>false</code> otherwise
+    # @return [boolean]  <code>true</code> if the receiver is a raw vector, <code>false</code> otherwise
     def raw?
       false
     end
     # check whether the <code>REXP</code> object is a complex vector
-    # @return <code>true</code> if the receiver is a complex vector, <code>false</code> otherwise
+    # @return [boolean] <code>true</code> if the receiver is a complex vector, <code>false</code> otherwise
     def complex?
       false
     end
     # check whether the <code>REXP</code> object is a recursive obejct
-    # @return <code>true</code> if the receiver is a recursive object, <code>false</code> otherwise
+    # @return [boolean] <code>true</code> if the receiver is a recursive object, <code>false</code> otherwise
     def recursive?
       false
     end
     # check whether the <code>REXP</code> object is a reference to an R object
-    # @return <code>true</code> if the receiver is a reference, <code>false</code> otherwise
+    # @return [boolean] <code>true</code> if the receiver is a reference, <code>false</code> otherwise
     def reference?
       false
     end
     
     # :section: basic accessor methods
-    # returns the contents as an array of Strings (if supported by the represented object)
+    
+    # returns the contents as an array of Strings (if supported by the represented object).
+    # 
+    # @return [Array] 
     def as_strings
       raise MismatchException, "String"
     end
     # returns the contents as an array of integers (if supported by the represented object)
+    # 
+    # @return [Array] 
     
     def as_integers
       raise MismatchException, "int"
     end
 
-    # returns the contents as an array of doubles (if supported by the represented object)
+    # returns the contents as an array of floats (C double precision) (if supported by the represented object).
+    # 
+    # @return [Array] 
+
     def as_doubles
        raise MismatchException,"double"
     end
 
-    # On Ruby, Float are stored in double precision
+    # On Ruby, Float are stored in double precision.
+    #
+    # @return [Array]
     def as_floats
       as_doubles
     end
     
-    # returns the contents as an array of bytes (if supported by the represented object)
+    # returns the contents as an array of bytes (if supported by the represented object).
+    # 
+    # @return [Array]
+    
     def as_bytes
       raise MismatchException , "byte"
     end
     # returns the contents as a (named) list (if supported by the represented object)
+    # 
+    # @return [Array]
     def as_list
       raise MismatchException,"list"
     end
-    # returns the contents as a factor (if supported by the represented object)
+    # returns the contents as a factor (if supported by the represented object).
+    #
+    # @return [RFactor]
     def as_factor
       raise MismatchException,"factor"
     end
     
-    # returns the length of a vector object. Note that we use R semantics here, i.e. a matrix will have a length of <i>m * n</i> since it is represented by a single vector (see {@link #dim} for retrieving matrix and multidimentional-array dimensions).
-    # * @return length (number of elements) in a vector object
-    # * @throws MismatchException if this is not a vector object
+    # returns the length of a vector object. Note that we use R semantics here, i.e. a matrix will have a length of <i>m * n</i> since it is represented by a single vector (see REXP.dim) for retrieving matrix and multidimentional-array dimensions).
+    # 
+    # @return [Integer] length (number of elements) in a vector object.
     def length
       raise MismatchException, "vector"
     end
     
-    # returns a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values
-    # *  @return a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values
-    # * @throws MismatchException if this is not a vector object
+    # returns a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values.
+    # 
+    # @return [boolean] a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values.
+    # 
     def na?
       raise MismatchException, "vector"
     end
     
     # :section: convenience accessor methods
+    
+    
     # convenience method corresponding to <code>as_integer()[0]</code>
-    # @return first entry returned by {@link #as_integer}
+    # 
+    # @return [Integer] first entry returned by as_integers()
     def as_integer
       as_integers[0]
     end
+    # Alias for as_integer().
+    #
+    # @return [Integer]
+    
     def to_i
       as_integers[0]
     end
-    # convenience method corresponding to <code>asDoubles()[0]</code>
-    # @return first entry returned by {@link #asDoubles}
+    # convenience method corresponding to <code>as_floats[0]</code>.
+    # 
+    # @return [Float] first entry returned by as_doubles()
     def as_double
       as_doubles[0]
     end
+    # Alias for as_double()
+    # 
+    # @return [Float]
     def as_float
       as_double
     end
+    # Alias for as_float()
+    # 
+    # @return [Float]
     def to_f
       as_double
     end
-    # convenience method corresponding to <code>asStrings()[0]</code>
-    # @return first entry returned by {@link #asStrings}
+    # convenience method corresponding to <code>as_strings[0]</code>.
+    # 
+    # @return [String] first entry returned by REXP.as_strings
     def as_string
       as_strings[0]
     end
-    # // methods common to all REXPs
     
-    # retrieve an attribute of the given name from this object
-    # * @param name attribute name
-    # * @return attribute value or <code>null</code> if the attribute does not exist
+    # :section: methods common to all REXPs
+    
+    # Retrieve an attribute of the given name from this object.
+    #
+    # @param [String] attribute name.
+    # @return [Rlist, nil] attribute value or <code>nil</code> if the attribute does not exist
     
     def get_attribute(name)
       has_attribute?(name)  ? @attr.as_list[name] : nil
     end
     
-    # checks whether this obejct has a given attribute
-    # * @param name attribute name
-    # * @return <code>true</code> if the attribute exists, <code>false</code> otherwise
+    # checks whether this object has a given attribute.
+    # 
+    # @param [String] attribute name.
+    # @return [boolean] <code>true</code> if the attribute exists, <code>false</code> otherwise
     def has_attribute? (name)
       !@attr.nil? and @attr.list? and !@attr.as_list[name].nil?
     end
@@ -198,8 +249,9 @@ module Rserve
     
     # :section: helper methods common to all REXPs
     
-    # returns dimensions of the object (as determined by the "<code>dim</code>" attribute)
-    #  @return an array of integers with corresponding dimensions or <code>null</code> if the object has no dimension attribute
+    # Returns dimensions of the object (as determined by the REXP::dim() attribute).
+    # 
+    #  @return [Array] an array of integers with corresponding dimensions or <code>nil</code> if the object has no dimension attribute
     def dim
     begin
       return has_attribute?("dim") ? @attr.as_list['dim'].as_integers :  nil;
@@ -209,9 +261,10 @@ module Rserve
     nil
     end
     
-    # determines whether this object inherits from a given class in the same fashion as the <code>inherits()</code> function in R does (i.e. ignoring S4 inheritance)
-    # @param klass class name
-    # @return <code>true</code> if this object is of the class <code>klass</code>, <code>false</code> otherwise
+    # determines whether this object inherits from a given class in the same fashion as the <code>inherits()</code> function in R does (i.e. ignoring S4 inheritance).
+    #
+    # @param [String] klass class name.
+    # @return [boolean] <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")
       begin
@@ -226,20 +279,23 @@ module Rserve
     
 
     
-    # returns representation that it useful for debugging (e.g. it includes attributes and may include vector values -- see {@link #maxDebugItems})
-    # @return extended description of the obejct -- it may include vector values
+    # returns representation that it useful for debugging (e.g. it includes attributes and may include vector values)
+    #
+    # @return [String] extended description of the obejct -- it may include vector values
     def to_debug_string
       (!@attr.nil?) ? (("<"+@attr.to_debug_string()+">")+to_s()) : to_s
     end
     
     
-    #//======= complex convenience methods
+    #  :section: complex convenience methods
+    
+    
     # returns the content of the REXP as a ruby matrix of doubles (2D-array: m[rows][cols]). You could use Matrix.rows(result) to create
     # a ruby matrix.
     # Matrix(c.eval("matrix(c(1,2,3,4,5,6),2,3)").as_double_matrix());</code>
     #
-    # @return 2D array of doubles in the form double[rows][cols] or <code>null</code> if the contents is no 2-dimensional matrix of doubles
-    def as_double_matrix()
+    # @return [Array] 2D array of doubles in the form double[rows][cols] or <code>nil</code> if the contents is no 2-dimensional matrix of doubles
+    def as_double_matrix
       ct = as_doubles()
       dim = get_attribute "dim"
       raise MismatchException, "matrix (dim attribute missing)" if dim.nil?
@@ -252,12 +308,16 @@ module Rserve
       # we need to copy everything, since we create 2d array from 1d array
       #r=m.times.map {|i| n.times.map {|j| ct[j*n+i]}}
     end
-    # Returns a standard library's matrix
+    # Returns a standard library's matrix.
+    #
+    # @return [Matrix]
     def as_matrix
       require 'matrix'
       Matrix.rows(as_double_matrix)
     end
     # Returns the content of the REXP as a serie of nested arrays of X dimensions
+    #
+    # @return [Array]
     def as_nested_array
       ct=as_doubles
       dim = get_attribute "dim"
@@ -267,7 +327,7 @@ module Rserve
       split_array(ct,ds)
     end
     
-    def split_array(ar, dims)
+    def split_array(ar, dims) # :nodoc:
 #      puts "#{ar} - #{dims}"
       if dims.size==1
         raise "Improper size ar:#{ar} , dims=#{dims[0]}" if ar.size!=dims[0]
@@ -296,10 +356,10 @@ module Rserve
     
     # :section: tools
     
-    # creates a data frame object from a list object using integer row names
-    # *  @param l a (named) list of vectors ({@link REXPVector} subclasses), each element corresponds to a column and all elements must have the same length
-    # *  @return a data frame object
-    #  *  @throws MismatchException if the list is empty or any of the elements is not a vector
+    # creates a data frame object from a list object using integer row names.
+    #
+    # *  @param [Rlist] a (named) list of vectors (REXP::Vector subclasses), each element corresponds to a column and all elements must have the same length.
+    # *  @return [GenericVector] a data frame object representation.
     def self.create_data_frame(l)
       raise(MismatchException, "data frame (must have dim>0)") if l.nil? or l.size<1
       raise MismatchException, "data frame (contents must be vectors)" if (!(l[0].is_a? REXP::Vector))
@@ -321,7 +381,8 @@ module Rserve
     # If R object has attributes, the Ruby object is extended with Rserve::WithAttributes.
     # If R object is names, the Ruby object is extended with Rserve::WithNames and
     # their elements can be accessed with [] using numbers and literals.
-    # 
+    #  
+    # @return [Object] Ruby object.
     def to_ruby
       #pp self
       v=to_ruby_internal
@@ -346,6 +407,9 @@ module Rserve
       
       v
     end
+    # Return the bare-bone representation of REXP as a Ruby Object. 
+    # Called by REXP.to_ruby, so shouldn't be used directly by developers.
+    # 
     def to_ruby_internal
       raise "You should implement to_ruby_internal for #{self.class}"
     end

data/lib/rserve/rexp/double.rb

@@ -7,6 +7,8 @@ module Rserve
       case Config::CONFIG['arch']
       when 'i686-linux'
         NA = 269653970229425383598692395468593241088322026492507901905402939417320933254485890939796955099302180188971623023005661539310855695935759376615857567599472873400528811349204333736152257830107446553333670133666606746438802800063353690283455789426038632208916715592554825644961573453826957827246636338344317943808
+      when /mswin/
+        NA = 269653970229425383598692395468593241088322026492507901905402939417320933254485890939796955099302180188971623023005661539310855695935759376615857567599472873400528811349204333736152257830107446553333670133666606746438802800063353690283455789426038632208916715592554825644961573453826957827246636338344317943808
       else
         NA = 0x100000000007a2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
       end
@@ -42,8 +44,13 @@ module Rserve
     end
 
     def na?(value=nil)
-      return value == NA unless value.nil?
-      @payload.map {|v| v==NA}
+      #if value.nil?
+      #  @payload.map {|v| v.respond_to? :nan and v.nan?}
+      #else  
+      #  value.respond_to? :nan? and value.nan?
+      #end
+      return value.to_i == NA unless value.nil?
+      @payload.map {|v| v.to_i==NA}
     end
     def to_debug_string
       t=super

data/lib/rserve/session.rb

@@ -0,0 +1,29 @@
+module Rserve
+  class Session
+    # serial version UID should only change if method signatures change
+    # significantly enough that previous versions cannot be used with
+    # current versions
+    include Rserve::Protocol
+    UID=-7048099825974875604
+    attr_reader :host
+    attr_reader :port
+    attr_reader :key
+    attr_reader :attach_packet
+    attr_reader :rsrv_version
+    def initialize(con,packet)
+      @host=con.hostname
+      @rsrv_version=con.rsrv_version
+      ct=packet.cont
+      if ct.nil? or ct.length!=32+3*4
+        raise "Invalid response to session detach request."
+      end
+      @port=get_int(ct,4)
+      @key=ct[12,32]
+    end
+    def attach
+      c=Rserve::Connection.new(:session=>self)
+      @attach_packet=c.rt.request(:cmd=>-1,:cont=>[])
+      c
+    end
+  end
+end

data/spec/rserve_connection_on_unix_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__)+"/spec_helper.rb"
+require 'rbconfig'
+describe "Rserve::Connection on unix" do
+  before do
+      @r=Rserve::Connection.new
+  end
+  if RbConfig::CONFIG['arch']!~/mswin/
+    it "method eval_void should raise an error with an incorrect expression" do
+      lambda {@r.void_eval("x<-")}.should raise_exception(Rserve::Connection::EvalError) {|e| e.request_packet.stat.should==2}
+      lambda {@r.void_eval("as.stt(c(1))")}.should raise_exception(Rserve::Connection::EvalError) {|e|
+      e.request_packet.stat.should==127}
+	  end
+	  it "method eval should raise an error with an incorrect expression" do
+      lambda {@r.eval("x<-")}.should raise_exception(Rserve::Connection::EvalError) {|e| e.request_packet.stat.should==2}
+      lambda {@r.eval("as.stt(c(1))")}.should raise_exception(Rserve::Connection::EvalError) {|e|
+      e.request_packet.stat.should==127}
+	  end
+    it "should raise ServerNotAvailable if started another instance on another port" do
+       lambda {Rserve::Connection.new(:port_number=>6700)}.should raise_exception(Rserve::Connection::ServerNotAvailable)
+    end
+    it "should create different session on *nix" do
+       s=Rserve::Connection.new
+       @r.assign("a", 1)
+       s.assign("a",2)
+       @r.eval('a').to_i.should==1
+       s.eval('a').to_i.should==2
+       s.close
+    end
+  else
+    it "shouldn't crash server with an incorrect expression as Windows version does"
+    it "shouldn't raise ServerNotAvailable if started another instance on another port as Windows version does"
+    it "shouldn create a different session. On Windows, every new connection closes previously open session"
+  end
+  
+end
+
+

data/spec/rserve_connection_spec.rb

@@ -10,9 +10,6 @@ describe Rserve::Connection do
       @r.last_error.should=="OK"
       @r.rt.should be_instance_of(Rserve::Talk)
     end
-    it "should raise ServerNotAvailable if started another instance on another port" do
-      lambda {Rserve::Connection.new(:port_number=>6700)}.should raise_exception(Rserve::Connection::ServerNotAvailable)
-    end
     it "should quit correctly" do
       @r.should be_connected
       @r.close.should be_true
@@ -35,24 +32,31 @@ describe Rserve::Connection do
     it "method eval_void should return true with correct expression" do
       @r.void_eval("x<-1").should be_true
     end
-    it "method eval_void should raise an error with an incorrect expression" do
-      lambda {@r.void_eval("x<-")}.should raise_exception(Rserve::Connection::EvalError) {|e| e.request_packet.stat.should==2}
-      lambda {@r.void_eval("as.stt(c(1))")}.should raise_exception(Rserve::Connection::EvalError) {|e|
-      e.request_packet.stat.should==127}
-    end
-
+    
     it "method eval should return a simple object" do
       la=@r.eval("TRUE")
       la.should be_instance_of(Rserve::REXP::Logical)
       la.true?.should==[true]
     end
-
-    it "method eval should raise an error with an incorrect expression" do
-      lambda {@r.eval("x<-")}.should raise_exception(Rserve::Connection::EvalError) {|e| e.request_packet.stat.should==2}
-      lambda {@r.eval("as.stt(c(1))")}.should raise_exception(Rserve::Connection::EvalError) {|e|
-      e.request_packet.stat.should==127}
+    it "should eval_void_detach correctly" do
+      s=@r.void_eval_detach("x<-c(TRUE,FALSE)")
+      @r.should_not be_connected      
+      s.should be_instance_of(Rserve::Session)
+      s.host.should==@r.hostname
+      s.key.size.should==32
+    end
+    it "should detach correctly" do
+      x=rand(100)
+     @r.void_eval("x<-#{x}")
+      s=@r.detach
+      @r.should_not be_connected      
+      s.should be_instance_of(Rserve::Session)
+      s.host.should==@r.hostname
+      s.key.size.should==32
+      r=s.attach
+      r.eval("x").to_ruby==x
     end
-
+    
     it "should eval_void and eval correctly" do
       @r.void_eval("x<-c(TRUE,FALSE)").should be_true
       la=@r.eval("x")
@@ -68,8 +72,10 @@ describe Rserve::Connection do
   describe "assign using REXPs" do
     before do
       @r=Rserve::Connection.new
-
     end
+    after do
+	    @r.close
+     end
     it "should assign double" do
       rexp=Rserve::REXP::Double.new([1.5,-1.5])
       @r.assign("x", rexp)

data/spec/rserve_protocol_spec.rb

@@ -44,6 +44,7 @@ describe Rserve::Protocol do
     buffer=[0xFF,0x78,0x56,0x34,0x12]
     expected=0x12345678
     @t.get_int(buffer,1).should==expected
+    @t.get_int(buffer,1).should==@t.get_int_original(buffer,1)
 
     # Version with errors
 
@@ -51,6 +52,9 @@ describe Rserve::Protocol do
     expected=0x12345678
     @t.get_int(buffer,1).should==expected
   end
+  
+  
+  
   it "get_len method should return correct length from a header" do
     cmd=Rserve::Protocol::CMD_login
     len=0x12345678
@@ -61,6 +65,7 @@ describe Rserve::Protocol do
     buffer=[0xFF,0x78,0x56,0x34,0x12,0x78,0x56,0x34,0x12]
     expected=0x1234567812345678
     @t.get_long(buffer,1).should==expected
+    @t.get_long(buffer,1).should==@t.get_long_original(buffer,1)
 
   end
   it "set_long method should set correct long(32 bits) for a given buffer" do

data/spec/rserve_rexp_to_ruby_spec.rb

@@ -5,6 +5,9 @@ describe "Rserve::REXP#to_ruby" do
     before do
       @r=Rserve::Connection.new
     end
+    after do
+      @r.close
+    end
     it "should return a Fixnum with vector with one integer element" do
       @r.eval("1").to_ruby.should==1
     end

data/spec/rserve_rexpfactory_spec.rb

@@ -7,7 +7,9 @@ describe Rserve::Protocol::REXPFactory do
   before do
     @r=Rserve::Connection.new
   end
-  
+  after do
+    @r.close
+  end
   it "should process null" do
     la=@r.eval("NULL")
     la.should be_instance_of(Rserve::REXP::Null)
@@ -29,6 +31,7 @@ describe Rserve::Protocol::REXPFactory do
   end
   it "should process logical vectors with NA" do
     la=@r.eval("c(TRUE,NA)")
+
     la.should be_instance_of(Rserve::REXP::Logical)
     la.na?.should==[false,true]
   end

data/spec/rserve_rlist_spec.rb

@@ -5,6 +5,9 @@ describe Rserve::Rlist do
     @r=Rserve::Connection.new
     @l=@r.eval("list(name='Fred',age=30,10,20,kids=c(1,2,3))").as_list
   end
+  after do
+    @r.close
+   end
   it "method names return correct names" do
     @l.names.should==['name','age',"","","kids"]
   end

data/spec/rserve_session_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__)+"/spec_helper.rb"
+describe Rserve::Session do
+  before do
+    @r=Rserve::Connection.new
+  end
+  it "should resume an detached session with void_eval_detach" do
+      x2=10+rand(12)
+      s=@r.void_eval_detach("x<-1:#{x2}")
+      r=Rserve::Connection.new
+      r.void_eval("x<-1")
+      r.eval("x").to_ruby.should==1
+      s.should be_instance_of(Rserve::Session)
+      r2=s.attach
+      r2.eval("x").to_ruby.should==(1..x2).to_a
+    end
+  it "should resume an detached session with detach" do
+      x2=10+rand(12)
+      @r.void_eval("x<-1:#{x2}")
+      s=@r.detach
+      r=Rserve::Connection.new
+      r.void_eval("x<-1")
+      r.eval("x").to_ruby.should==1
+      s.should be_instance_of(Rserve::Session)
+      r2=s.attach
+      r2.eval("x").to_ruby.should==(1..x2).to_a
+    end    
+end

data/spec/rserve_spec.rb

@@ -4,6 +4,9 @@ describe Rserve do
   before do
     @r=Rserve::Connection.new()
   end
+  after do
+	  @r.close
+  end
   it "should calcule a basic LR without hazzle" do
     script=<<-EOF
 ## Disease severity as a function of temperature

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 9
-  version: 0.1.9
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Claudio Bustos
@@ -35,7 +35,7 @@ cert_chain:
   rpP0jjs0
   -----END CERTIFICATE-----
 
-date: 2010-06-04 00:00:00 -04:00
+date: 2010-06-16 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -62,8 +62,8 @@ dependencies:
         segments: 
         - 2
         - 6
-        - 0
-        version: 2.6.0
+        - 1
+        version: 2.6.1
   type: :development
   version_requirements: *id002
 description: |-
@@ -88,6 +88,10 @@ files:
 - Manifest.txt
 - README.txt
 - Rakefile
+- benchmark/benchmark.rb
+- benchmark/comparison_2010_06_07.xls
+- benchmark/comparison_2010_06_07_using_pack.xls
+- benchmark/plot.rb
 - data/gettysburg.txt
 - examples/gettysburg.rb
 - examples/hello_world.rb
@@ -120,9 +124,11 @@ files:
 - lib/rserve/rexp/wrapper.rb
 - lib/rserve/rfactor.rb
 - lib/rserve/rlist.rb
+- lib/rserve/session.rb
 - lib/rserve/talk.rb
 - lib/rserve/withattributes.rb
 - lib/rserve/withnames.rb
+- spec/rserve_connection_on_unix_spec.rb
 - spec/rserve_connection_spec.rb
 - spec/rserve_double_spec.rb
 - spec/rserve_genericvector_spec.rb
@@ -136,6 +142,7 @@ files:
 - spec/rserve_rexpfactory_spec.rb
 - spec/rserve_rfactor_spec.rb
 - spec/rserve_rlist_spec.rb
+- spec/rserve_session_spec.rb
 - spec/rserve_spec.rb
 - spec/rserve_talk_spec.rb
 - spec/rserve_withnames_spec.rb
@@ -181,11 +188,13 @@ test_files:
 - spec/rserve_double_spec.rb
 - spec/rserve_withnames_spec.rb
 - spec/rserve_packet_spec.rb
+- spec/rserve_connection_on_unix_spec.rb
 - spec/rserve_rexpfactory_spec.rb
 - spec/rserve_rexp_spec.rb
 - spec/rserve_integer_spec.rb
 - spec/rserve_spec.rb
 - spec/rserve_protocol_spec.rb
 - spec/rserve_genericvector_spec.rb
+- spec/rserve_session_spec.rb
 - spec/rserve_logical_spec.rb
 - spec/rserve_talk_spec.rb