rserve-client 0.1.3 → 0.1.4

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.1.4 / 2010-05-24
+* Bug fix: Incorrect NA for Logical, String and Double Vector
+* Factors implemented
+
 === 0.1.3 / 2010-05-24
 * Better README.txt
 * Implemented hash of options on Connection.new

data/Rakefile

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

data/lib/rserve.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 module Rserve
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end
 
 
@@ -12,3 +12,5 @@ require 'rserve/rexp'
 require 'rserve/engine'
 require 'rserve/connection'
 require 'rserve/rlist'
+require 'rserve/rfactor'
+

data/lib/rserve/protocol/rexpfactory.rb

@@ -177,8 +177,9 @@ module Rserve
             d=Array.new(as)
             (eox-i).times {|i| d[i]=buf[o+i]}
             o=eox
+
             d.length.each {|j| 
-              if d[j]!=0 && d[j]!=1 
+              if d[j]!=0 and d[j]!=1
                 d[j]==REXP::Logical::NA
               end
             }
@@ -190,9 +191,11 @@ module Rserve
             o+=4
             d=Array.new(as)
             as.times {|i| d[i]=buf[o+i]}
-            d.length.times {|j| 
-              if d[j]!=0 && d[j]!=1 
-                d[j]==REXP::Logical::NA
+            d.collect! {|v| 
+              if v!=0 and v!=1
+                REXP::Logical::NA
+              else
+                v
               end
             }
             o=eox

data/lib/rserve/rexp.rb

@@ -227,9 +227,10 @@ end
 
 require 'rserve/rexp/vector'
 require 'rserve/rexp/null'
-
 require 'rserve/rexp/genericvector'
 require 'rserve/rexp/integer'
+require 'rserve/rexp/factor'
+
 require 'rserve/rexp/double'
 require 'rserve/rexp/list'
 require 'rserve/rexp/language'

data/lib/rserve/rexp/double.rb

@@ -2,7 +2,8 @@ module Rserve
   class REXP
     class Double < REXP::Vector
       attr_reader :payload
-      NA = 0x7ff00000000007a2;
+      # In Java, you only need to add L at last :(
+      NA = 0x100000000007a2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
       def initialize(data, attrs=nil)
         @payload=case data
           when Numeric

data/lib/rserve/rexp/logical.rb

@@ -13,12 +13,13 @@ module Rserve
           @payload.map {|v| v==NA}
         end
       end
+      # l should be a value or array of 0 and 1.
       def initialize(l,attr=nil)
         super(attr)
         if l.is_a? Array
-          @payload=l.map {|l| l==1 ? TRUE : FALSE}
+          @payload= l 
         else
-          @payload = [ l==1 ? TRUE : FALSE ]
+          @payload = [ l==NA ? NA : (l==1 ? TRUE : FALSE) ]
         end
       end
       def length
@@ -27,6 +28,9 @@ module Rserve
       def logical?
         true
       end
+      def as_bytes
+        @payload
+      end
       def as_integers
         @payload.map {|v| v==NA ? REXP::Integer::NA : ( v == FALSE ? 0 : 1 )} 
       end
@@ -41,7 +45,6 @@ module Rserve
       end
       def false?
         @payload.map {|v| v==FALSE}
-        
       end
     end
   end

data/lib/rserve/rexp/string.rb

@@ -22,7 +22,7 @@ module Rserve
       end
       
       def na?
-        @payload.map {|v| v.nil}
+        @payload.map {|v| v=='NA'}
       end
       def to_debug_string
         t=super

data/spec/rserve_logical_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__)+"/spec_helper.rb"
+
+describe Rserve::REXP::Integer do
+  describe "initialization" do
+    it "should accept array as payload" do
+      payload=[0,1,0]
+      a=Rserve::REXP::Logical.new(payload)
+      a.payload.should==payload
+    end
+    it "should accept a single value as payload" do
+      payload=1
+      a=Rserve::REXP::Logical.new(payload)
+      a.payload.should==[ Rserve::REXP::Logical::TRUE ]
+    end
+  end
+    describe "common methods" do
+    before do
+      @n=rand(100)
+      @payload=@n.times.map {rand(2)}
+      @a=Rserve::REXP::Logical.new(@payload)
+    end
+    subject {@a}
+    it "should return correct length of payload" do
+      @a.length.should==@n
+    end
+    it {should be_logical}
+    it "method as_bytes should return payload" do
+      @a.as_bytes.should==@payload
+    end
+    it "method as_integer should return integers" do
+      @a.as_integers.should==@payload.map {|v| v==Rserve::REXP::Logical::TRUE ? 1 : 0}
+    end
+    it "method as_doubles should return floats" do
+      @a.as_doubles.should==@payload.map {|v| v==Rserve::REXP::Logical::TRUE ? 1.0 : 0.0}
+    end
+    it "method as_string should return string" do
+      @a.as_strings.should==@payload.map {|v| v==Rserve::REXP::Logical::TRUE ? "TRUE" : "FALSE"}
+    end
+    it "method true? should return an array with true for TRUE values" do
+      @a.true?.should==@payload.map {|v| v==Rserve::REXP::Logical::TRUE ? true :false}
+    end
+    it "method false? should return an array with true for FALSE values" do
+      @a.false?.should==@payload.map {|v| v==Rserve::REXP::Logical::FALSE ? true :false}
+    end
+
+    it "method is_NA should return coherent answer" do
+      payload=[1,Rserve::REXP::Logical::NA, 0]
+      a=Rserve::REXP::Logical.new(payload)
+      a.na?.should==[false,true,false]
+      a.na?(a.as_bytes[0]).should be_false
+      a.na?(a.as_bytes[1]).should be_true
+    end
+    it "method to_debug_string and to_s returns a coherent response" do
+      @a.to_debug_string.size.should>0
+      @a.to_s.size.should>0
+      
+    end
+    end
+  
+  
+end

data/spec/rserve_rexpfactory_spec.rb

@@ -16,6 +16,11 @@ describe Rserve::Protocol::REXPFactory do
     la.should be_instance_of(Rserve::REXP::Logical)
     la.true?.should==[true,false,true]
   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
   it "should process single double" do
     la=@r.eval("1.5")
     la.should be_instance_of(Rserve::REXP::Double)
@@ -30,11 +35,38 @@ describe Rserve::Protocol::REXPFactory do
       v.should be_close(a[i],1e-10)
     }
   end
-  it "should process char" do
+  it "should process double vector with NA" do
+    la=@r.eval("c(1,NA)")
+    la.should be_instance_of(Rserve::REXP::Double)
+    la.na?.should==[false,true]
+    
+  end
+  it "should process string vector" do
     la=@r.eval("c('abc','def','ghi')")
     la.should be_instance_of(Rserve::REXP::String)
     la.as_strings.should==['abc','def','ghi']
   end
+  it "should process string vector with NA" do
+    la=@r.eval("c('abc','def',NA)")
+    la.should be_instance_of(Rserve::REXP::String)
+    la.na?.should==[false,false,true]
+
+  end
+  it "should process factor" do
+    la=@r.eval <<-EOF
+    state <- c("tas", "sa",  "qld", "nsw", "nsw", "nt",  "wa",  "wa",
+                  "qld", "vic", "nsw", "vic", "qld", "qld", "sa",  "tas",
+                  "sa",  "nt",  "wa",  "vic", "qld", "nsw", "nsw", "wa",
+                  "sa",  "act", "nsw", "vic", "vic", "act");
+    statef <- factor(state)
+    EOF
+    la.should be_factor
+    la.as_factor.levels.sort.should==%w{act nsw nt  qld sa tas vic wa}.sort
+
+    la.as_factor.contains?("tas").should be_true
+    la.as_factor.contains?("nn").should be_false
+
+  end
   it "should process list" do
     require 'pp'
     la=@r.eval("list(name='Fred',age=30,10,20,kids=c(1,2,3))")

data/spec/rserve_rfactor_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__)+"/spec_helper.rb"
+
+describe Rserve::RFactor do
+  before do
+    @levels=['a','b','c','d']
+    @ids=[1,1,2,2,3,3,4]
+    @base_index=1
+    @factor=Rserve::RFactor.new(@ids,@levels,false,@base_index)
+  end
+  it "method size should return number of ids" do
+    @factor.size.should==@ids.size
+  end
+  it "method [] should return correct value (1 based)" do
+    @ids.each_index {|i|
+      @factor[i].should == @levels[@ids[i]-@base_index]
+      @factor[1].should=='a'
+      @factor[3].should=='b'
+      @factor[5].should=='c'
+      
+    }
+  end
+  it "methods contains? should work with integers and strings" do
+    @factor.contains?(1).should be_true
+    @factor.contains?(5).should be_false
+    @factor.contains?('a').should be_true
+    @factor.contains?('z').should be_false
+  end
+  it "methods count should work with integers and strings" do
+    @factor.count(2).should==2
+    @factor.count(5).should==0
+    @factor.count('a').should==2
+    @factor.count('z').should==0
+  end
+  it "method counts_hash should return correct value" do
+    @factor.counts_hash.should=={'a'=>2,'b'=>2,'c'=>2,'d'=>1}
+  end
+  it "method as_integers should return correct values" do
+    @factor.as_integers.should==@ids
+  end
+
+  it "method as_strings should return correct values" do
+    @factor.as_strings==%w{a a b b c c d}
+  end
+  
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Claudio Bustos
@@ -149,5 +149,15 @@ rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Ruby client for Rserve, a Binary R server (http://www.rforge.net/Rserve/)
-test_files: []
-
+test_files: 
+- spec/rserve_rfactor_spec.rb
+- spec/rserve_connection_spec.rb
+- spec/rserve_double_spec.rb
+- spec/rserve_packet_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_logical_spec.rb
+- spec/rserve_talk_spec.rb