rserve-client 0.2.0 → 0.2.1

data.tar.gz.sig

@@ -1 +1 @@
-]�#M2� �h >-�%�̤��AlՏ�Ĥ�v�o�"*&�i-��8
��������{����G�e��)\�@RM΄��P�O���e�=�h��S���@p3uA����|%z$���}C+M���B�c�����5}�I���fF�M�xL�.$���J�t�W�TT��[��4����TgϠ&0�;,v&C~Ť�؍����.zI� �y-
�Q�s7s�1R��TY�D0��q��k^�5�V�ny	�=ϺI
_
+!8��M���C�+G[I��j�8����%��\`k��"�H��}m��܎����y�_�M��!ƩV9-�y�&�mL<�ˆ�74>�B"{�CW�}â:__}����Y{��L�w{2�H���>�S�L�璛����52��H��,)4M�^�+Y���,p����ٝ�0/�^+<��$Ye����TWΏ�eܔ1��#�"�

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.2.1 / 2010-06-18
+* Added suport to assign ruby std lib Matrix. Bug fix on retrieving matrix
+* Fixed whitespace problem on README.txt
+
 === 0.2.0 / 2010-06-15
 * Session implemented. 
 * Retrieve auth information from server first responde. TODO: Implement authentification

data/README.txt

@@ -15,19 +15,19 @@ Follows closely the new Java client API, but maintains all Ruby conventions when
 * Uses TCP/IP sockets to interchange data and commands
 * 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.
-  * 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
-    * From Ruby side: Every REXP objects has a <tt>to_ruby</tt> method, which automagicly converts every R type on equivalent Ruby type. So, a vector of size 1 is converted to an integer or double, a vector of size>1 returns an array, a named list returns a hash and so on. If you need to create a complex expression, you could always use method <tt>eval</tt> without problem
+* Work with Ruby 1.8, 1.9 and JRuby 1.5.
+* 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
+  * From Ruby side: Every REXP objects has a <tt>to_ruby</tt> method, which automagicly converts every R type on equivalent Ruby type. So, a vector of size 1 is converted to an integer or double, a vector of size>1 returns an array, a named list returns a hash and so on. If you need to create a complex expression, you could always use method <tt>eval</tt> without problem
 Cons:
-  * Requires Rserve
- 
+* Requires Rserve
+
 == RELATED LIBRARIES (Ruby / R)
 
 * Rinruby [http://rinruby.ddahl.org/]

data/lib/rserve.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 module Rserve
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end
 
 

data/lib/rserve/rexp.rb

@@ -323,26 +323,31 @@ module Rserve
       dim = get_attribute "dim"
       raise MismatchException, "array (dim attribute missing" if dim.nil?
       ds = dim.as_integers.reverse
-      
       split_array(ct,ds)
     end
     
     def split_array(ar, dims) # :nodoc:
-#      puts "#{ar} - #{dims}"
+      #puts "#{ar} - #{dims}"
       if dims.size==1
         raise "Improper size ar:#{ar} , dims=#{dims[0]}" if ar.size!=dims[0]
         return ar 
       elsif dims.size==2
+        dims.reverse!
         # should rearrange values as R do
+        # dims[0]=cols, dims[1]=rows
+        if(true)
         out=[]
         ar.each_with_index {|v,i| 
-          r=(i/dims[1]).to_i;
-          c=i%dims[1];
-#          p "#{r} : #{c}";
-          out[c*dims[0]+r]=v
+          r=(i/dims[0]).to_i;
+          c=i%dims[0];
+          #p "#{r} : #{c}";
+          out[c*dims[1]+r]=v
         }
+        #p out
+        
         raise "out size should equal to ar size" if ar.size!=out.size
         ar=out
+        end
       end
       dims_c=dims.dup
       current_dim=dims_c.shift

data/lib/rserve/rexp/wrapper.rb

@@ -11,28 +11,45 @@ module Rserve
     module Wrapper
       def self.wrap(o)
         return o if o.is_a? REXP
+        return o.to_REXP if o.respond_to? :to_REXP
         case o
-        when TrueClass
-          REXP::Logical.new(1)
-        when FalseClass
-          REXP::Logical.new(0)
-        when NilClass
-          REXP::Null.new()
-        when ::String
-          REXP::String.new(o)
-        when Integer
-          REXP::Integer.new(o)
-        when Fixnum
-          REXP::Integer.new(o)
-        when Float
-          REXP::Double.new(o)
-        when Array
-          find_type_of_array(o)
-        else
-          puts "Clase:#{o.class}"
-          nil
+          when TrueClass
+            REXP::Logical.new(1)
+          when FalseClass
+            REXP::Logical.new(0)
+          when NilClass
+            REXP::Null.new()
+          when ::String
+            REXP::String.new(o)
+          when Integer
+            REXP::Integer.new(o)
+          when Fixnum
+            REXP::Integer.new(o)
+          when Float
+            REXP::Double.new(o)
+          when Array
+            find_type_of_array(o)
+          when ::Matrix
+            create_matrix(o)
+          else
+            nil
         end
       end
+      def self.create_matrix(o)
+        data= o.column_size.times.map {|j|
+          o.column(j).to_a
+        }.flatten
+        attr=REXP::List.new(
+          Rlist.new(
+            [
+            REXP::String.new("matrix"),
+            REXP::Integer.new([o.row_size, o.column_size])
+            ],
+            ["class", "dim" ]
+            )
+          )
+        REXP::Double.new(data, attr)
+      end
       def self.find_type_of_array(o)
         if o.all? {|v| v.nil?}
           REXP::Integer.new([REXP::Integer::NA]*o.size)

data/spec/rserve_connection_spec.rb

@@ -123,11 +123,21 @@ describe Rserve::Connection do
       @r.eval("x").should==x
     end
     it "should assign a matrix" do
-      x=@r.eval("matrix(1:9,3,3)")
+      x=@r.eval("matrix(1:12,6,2)")
       @r.assign("x",x)
       @r.eval("x").should==x
-      
     end
+    it "should assign a ruby matrix" do
+      mat_ruby=Matrix[[1,7],[2,8],[3,9],[4,10],[5,11],[6,12]]
+      @r.assign('x',mat_ruby)
+      x=@r.eval('x')
+      y=@r.eval('y<-matrix(c(1,2,3,4,5,6,7,8,9,10,11,12),6,2)')
+      #p x.attr.to_ruby
+      x.as_floats.should==y.as_floats
+      x.attr.as_list['dim'].should==y.attr.as_list['dim']
+      x.to_ruby.should==mat_ruby
+    end
+    
     after do
       @r.void_eval("rm(x)")
     end

data/spec/rserve_rexp_to_ruby_spec.rb

@@ -38,7 +38,7 @@ describe "Rserve::REXP#to_ruby" do
       a.attributes['names'].should==%w{a b c}
     end
     it "should return a Ruby Matrix with R matrix" do
-      @r.eval("matrix(c(1,2,3,4),2,2)").to_ruby.should==Matrix[[1,3],[2,4]]
+      @r.eval("matrix(c(1:12),6,2)").to_ruby.should==Matrix[[1,7],[2,8],[3,9],[4,10],[5,11], [6,12]]
     end
     it "should return a nested array of Ruby Matrixes with vector with more than tree dimensions"  do
       @r.void_eval("a<-1:16; attr(a,'dim')<-c(2,2,2,2)")

data/spec/rserve_rexp_wrapper_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__)+"/spec_helper.rb"
-
+require 'matrix'
 describe Rserve::REXP::Wrapper do
   it "should wrap single value" do
     Rserve::REXP::Wrapper.wrap(1).should==Rserve::REXP::Integer.new(1)
@@ -13,6 +13,20 @@ describe Rserve::REXP::Wrapper do
     Rserve::REXP::Wrapper.wrap([true,false]).should==Rserve::REXP::Logical.new([1,0])
     Rserve::REXP::Wrapper.wrap(["a","b"]).should==Rserve::REXP::String.new(["a","b"])
   end
+  it "should wrap a standard library matrix" do 
+    mat=Matrix[[1,2],[3,4]]
+    expected=Rserve::REXP::Double.new([1,3,2,4], Rserve::REXP::List.new( Rserve::Rlist.new( 
+      [
+      Rserve::REXP::String.new('matrix'),
+      Rserve::REXP::Integer.new([2,2])
+      ],
+      ['class','dim']
+      )
+     )
+    )
+    Rserve::REXP::Wrapper.wrap(mat).should==expected
+  end
+  
   it "should wrap on a list mixed values" do
     r=Rserve::Connection.new
     Rserve::REXP::Wrapper.wrap([1,2.0,false,"a"]).should==

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Claudio Bustos
@@ -35,7 +35,7 @@ cert_chain:
   rpP0jjs0
   -----END CERTIFICATE-----
 
-date: 2010-06-16 00:00:00 -04:00
+date: 2010-06-18 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency