r_type 0.0.3

data/sample/sample4.rb

@@ -0,0 +1,43 @@
+require '../lib/r_type'
+
+R.run do
+  a = matrix [0, 1, 2, 3, 4, 5, 6, 7, 9], ncol: 3
+  b = matrix [1, 0, -2]
+
+  print a
+  print b
+  print solve(a, b)
+  #          x    y    z
+  #  -----------------------
+  #  [1,] |  0    3    6 = 1
+  #  [2,] |  1    4    7 = 0
+  #  [3,] |  2    5    9 = -2
+  #
+  # x = -2.333333
+  # y =  2.333333
+  # z = -1.000000
+
+  library("MASS")
+  c = matrix [1, 2, 3, 4, 5, 6, 7, 8, 9], ncol: 3
+  print ginv(c)
+end
+# >>      [,1] [,2] [,3]
+# >> [1,]    0    3    6
+# >> [2,]    1    4    7
+# >> [3,]    2    5    9
+# >>      [,1]
+# >> [1,]    1
+# >> [2,]    0
+# >> [3,]   -2
+# >>           [,1]
+# >> [1,] -2.333333
+# >> [2,]  2.333333
+# >> [3,] -1.000000
+# >>            [,1] [,2] [,3]
+# >> [1,] -0.3333333   -1    1
+# >> [2,] -1.6666667    4   -2
+# >> [3,]  1.0000000   -2    1
+# >>            [,1]          [,2]       [,3]
+# >> [1,] -0.6388889 -5.555556e-02  0.5277778
+# >> [2,] -0.1666667 -2.428613e-17  0.1666667
+# >> [3,]  0.3055556  5.555556e-02 -0.1944444

data/sample/sample5.rb

@@ -0,0 +1,61 @@
+require '../lib/r_type'
+
+R.run do
+  a = matrix [3, 0, 0, 0, 4, 0, 0, 0, 1], ncol: 3
+  print eigen(a)
+  print svd(a)
+
+  b = matrix [0, 1, 2, 3, 4, 5, 6, 7, 9], ncol: 3
+  print eigen(b)
+  print qr(b)
+end
+# >> $values
+# >> [1] 4 3 1
+# >>
+# >> $vectors
+# >>      [,1] [,2] [,3]
+# >> [1,]    0    1    0
+# >> [2,]    1    0    0
+# >> [3,]    0    0    1
+# >>
+# >> $d
+# >> [1] 4 3 1
+# >>
+# >> $u
+# >>      [,1] [,2] [,3]
+# >> [1,]    0    1    0
+# >> [2,]    1    0    0
+# >> [3,]    0    0    1
+# >>
+# >> $v
+# >>      [,1] [,2] [,3]
+# >> [1,]    0    1    0
+# >> [2,]    1    0    0
+# >> [3,]    0    0    1
+# >>
+# >> $values
+# >> [1] 13.985686 -1.169156  0.183470
+# >>
+# >> $vectors
+# >>            [,1]       [,2]       [,3]
+# >> [1,] -0.4263524 -0.9366202  0.2264150
+# >> [2,] -0.5474684 -0.2042614 -0.8684128
+# >> [3,] -0.7200708  0.2846399  0.4411298
+# >>
+# >> $qr
+# >>            [,1]       [,2]        [,3]
+# >> [1,] -2.2360680 -6.2609903 -11.1803399
+# >> [2,]  0.4472136  3.2863353   6.3900965
+# >> [3,]  0.8944272  0.9990708   0.4082483
+# >>
+# >> $rank
+# >> [1] 3
+# >>
+# >> $qraux
+# >> [1] 1.0000000 1.0430999 0.4082483
+# >>
+# >> $pivot
+# >> [1] 1 2 3
+# >>
+# >> attr(,"class")
+# >> [1] "qr"

data/spec/convert_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe RType::Convert do
+  let!(:rsruby)   { rsruby_stub }
+  let(:converter) { RType::Convert.new }
+
+  def robj original_value
+    rsruby_obj = double("rsruby::robj (#{original_value})")
+    rsruby_obj.stub(:to_ruby).and_return original_value
+    rsruby_obj
+  end
+
+  describe '#convert' do
+    let(:converted_value) { value }
+    let(:length_val) { 0 }
+
+    shared_examples_for 'convert RObj to' do |klass|
+      before do
+        rsruby.stub(:[]).with(:length).and_return double(call: length_val)
+        rsruby.stub(:[]).with(:class).and_return double(call: r_class)
+        rsruby.stub(:[]).with(:mode).and_return 'numeric'
+        @robj = robj(value)
+        ::RObj.stub(:===).with(@robj).and_return true
+      end
+
+      subject { converter.convert @robj }
+      it      { should be_a klass }
+      it      { should == converted_value }
+    end
+
+    context 'DataFrame' do
+      let(:value)   { { x: [1,2,3] } }
+      let(:r_class) { 'data.frame' }
+      it_behaves_like 'convert RObj to', RType::DataFrame
+    end
+
+    context 'Function' do
+      let(:value)   { 'R-function' }
+      let(:r_class) { 'function' }
+      it_behaves_like 'convert RObj to', RType::Function
+    end
+
+    context 'List' do
+      let(:value)   { [1, 2, 3] }
+      let(:r_class) { 'list' }
+      it_behaves_like 'convert RObj to', RType::List
+    end
+
+    context 'Array' do
+      let(:value)   { [1, 2, 3] }
+      let(:r_class) { 'array' }
+      it_behaves_like 'convert RObj to', RType::Array
+    end
+
+    context 'Matrix' do
+      let(:value)   { [[1, 2], [3, 4]] }
+      let(:r_class) { 'matrix' }
+      let(:converted_value) { ::Matrix.rows value }
+      it_behaves_like 'convert RObj to', RType::Matrix
+    end
+
+    context 'Vector' do
+      let(:length_val) { 2 }
+      let(:value)   { [1, 2, 3] }
+      let(:r_class) { 'numeric' }
+      it_behaves_like 'convert RObj to', RType::Vector
+    end
+
+    context 'String' do
+      let(:value)   { "hello world" }
+      let(:r_class) { 'character' }
+      it_behaves_like 'convert RObj to', RType::String
+    end
+
+    context 'Numeric' do
+      let(:value)   { 99.0 }
+      let(:r_class) { 'numeric' }
+      it_behaves_like 'convert RObj to', RType::Numeric
+    end
+
+    context 'Integer' do
+      let(:value)   { 31 }
+      let(:r_class) { 'integer' }
+      it_behaves_like 'convert RObj to', RType::Integer
+    end
+
+    context 'Base' do
+      let(:value)   { 100 }
+      let(:r_class) { 'unknown' }
+      it_behaves_like 'convert RObj to', RType::Base
+    end
+  end
+end

data/spec/core_ext/boolean_delegate_r_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe RType::CoreExt::BooleanDelegateR do
+  let(:num)    { 3 }
+  let(:matrix) { RType::Matrix[[1, 3], [2, 4]] }
+
+  describe '<' do
+    subject { num < matrix }
+
+    it 'Matrix[[false, false], [false, true]]' do
+      subject[1, 1].should be_false
+      subject[1, 2].should be_false
+      subject[2, 1].should be_false
+      subject[2, 2].should be_true
+    end
+  end
+
+  describe '>' do
+    subject { num > matrix }
+
+    it 'Matrix[[true, false], [true, false]]' do
+      subject[1, 1].should be_true
+      subject[1, 2].should be_false
+      subject[2, 1].should be_true
+      subject[2, 2].should be_false
+    end
+  end
+
+  describe '=~' do
+    subject { num =~ matrix }
+
+    it 'Matrix[[false, true], [false, false]]' do
+      subject[1, 1].should be_false
+      subject[1, 2].should be_true
+      subject[2, 1].should be_false
+      subject[2, 2].should be_false
+    end
+  end
+end

data/spec/core_ext/numeric_delegate_r_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe RType::CoreExt::NumericDelegateR do
+  let(:num)    { 100 }
+  let(:matrix) { RType::Matrix[[1, 3], [2, 4]] }
+
+  describe '+' do
+    subject { num + matrix }
+    it      { should == RType::Matrix[[101, 103], [102, 104]] }
+  end
+
+  describe '-' do
+    subject { num - matrix }
+    it      { should == RType::Matrix[[99, 97], [98, 96]] }
+  end
+
+  describe '/' do
+    let(:num) { 12 }
+    subject { num / matrix }
+    it      { should == RType::Matrix[[12.0, 4.0], [6.0, 3.0]] }
+  end
+
+  describe '*' do
+    subject { num * matrix }
+    it      { should == RType::Matrix[[100, 300], [200, 400]] }
+  end
+end

data/spec/helper/robj_delegatable_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe RType::Helper::RObjDelegatable do
+  let(:klass) do
+    Class.new(Delegator) do
+      include RType::Helper::RObjDelegatable
+
+      def initialize robj=nil, ruby_obj=nil
+        if robj
+          @robj = robj
+        else
+          @ruby_obj = ruby_obj
+        end
+      end
+    end
+  end
+  let(:ruby_obj) { double("ruby_obj") }
+  let(:robj)     { double("robj") }
+  let(:r_stub)   { double("R") }
+
+  before do
+    robj.stub(:to_ruby).with(RSRuby::BASIC_CONVERSION).and_return ruby_obj
+    robj.stub(:as_r).and_return robj
+    ruby_obj.stub_chain(:as_r, :robj).and_return robj
+  end
+
+  context 'has R-obj' do
+    subject { klass.new robj, nil }
+
+    its(:ruby_obj) { should == ruby_obj }
+    its(:robj)     { should == robj }
+    its(:as_r)     { should == robj }
+    its(:to_ruby)  { should == ruby_obj }
+    its(:inspect)  { should =~ /RType::.*robj/ }
+
+    it 'delegate a method to R' do
+      R.stub(:[]).with('+') { r_stub }
+      r_stub.stub(:call).with(subject, 100).and_return 150
+      expect(subject + 100).to be_eql 150
+    end
+
+    it 'delegate a method to Ruby' do
+      ruby_obj.should_receive(:hoge).and_return 'Hello world'
+      expect(subject.hoge).to be_eql 'Hello world'
+    end
+  end
+
+  context 'has Ruby-obj' do
+    subject { klass.new nil, ruby_obj }
+
+    its(:ruby_obj) { should == ruby_obj }
+    its(:robj)     { should == robj }
+    its(:as_r)     { should == robj }
+    its(:to_ruby)  { should == ruby_obj }
+    its(:inspect)  { should =~ /RType::.*ruby_obj/ }
+
+    it 'delegate a method to R' do
+      R.stub(:[]).with('+') { r_stub }
+      r_stub.stub(:call).with(subject, 100).and_return 150
+      expect(subject + 100).to be_eql 150
+    end
+
+    it 'delegate a method to Ruby' do
+      ruby_obj.should_receive(:hoge).and_return 'Hello world'
+      expect(subject.hoge).to be_eql 'Hello world'
+    end
+  end
+end

data/spec/r_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe RType::R do
+  describe '#lazy_expression' do
+    before { @exp = RType::R.lazy_expression('function(x) x * 10') }
+
+    it 'should be a R function' do
+      @exp.call(3.0).to_ruby.should == 30
+    end
+  end
+
+  describe '#method_missing' do
+    context 'call a RSRuby method' do
+      subject { RType::R.eval_R '11 + 44' }
+      it      { should == 55 }
+    end
+
+    context 'call a R-function' do
+      subject { RType::R.sum 11, 22 }
+      it      { should == 33 }
+    end
+
+    context 'assign a value to R-variable' do
+      before  { RType::R.x = 100 }
+      subject { RType::R.x }
+      it      { should == 100 }
+    end
+
+    context 'get a R-variable' do
+      before  { RType::R.eval_R 'y = 900' }
+      subject { RType::R.y }
+      it      { should == 900 }
+    end
+  end
+end
+
+describe ::R do
+  it { should == RType::R }
+
+  describe 'R::Matrix' do
+    subject { ::R::Matrix }
+    it      { should == ::RType::Matrix }
+  end
+
+  describe 'R::List' do
+    subject { ::R::List }
+    it      { should == ::RType::List }
+  end
+
+  describe 'R::Vector' do
+    subject { ::R::Vector }
+    it      { should == ::RType::Vector }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../lib/r_type', __FILE__)
+
+module RType::SpecDSL
+  def rsruby_stub
+    rsruby = double("rsruby")
+    RType::R.stub(:rsruby).and_return(rsruby)
+    proc_table = {}
+    rsruby.stub(:default_mode=).with(4)
+    rsruby.stub(:proc_table) { proc_table }
+    rsruby
+  end
+
+  def rsruby_func_stub rsruby, name, args, response
+    func = double(name.to_s)
+    func.stub(:call).with(*args).and_return response
+    func.stub(:is_function?).and_return true
+    rsruby.stub(:[]).with(name).and_return func
+    func
+  end
+
+  def rsruby_variable_stub rsruby, name, value
+    variable = RType::Base.new double(name.to_s)
+    variable.stub(:to_ruby).and_return value
+    variable.stub(:is_function?).and_return false
+    rsruby_func_stub rsruby, :assign, [name.to_s, value], variable
+    rsruby.stub(:[]).with(name).and_return variable
+    variable
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+  config.include RType::SpecDSL
+end

data/spec/type/base_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe RType::Base do
+  context 'c(1,2,3)' do
+    subject { R.eval_R("c(1,2,3)") }
+
+    it { should be_include 3 }
+    it { should == [1.0, 2.0, 3.0] }
+
+    its(:to_ruby) { should == [1.0, 2.0, 3.0] }
+    its('to_ruby.inspect') { should == '[1.0, 2.0, 3.0]' }
+  end
+
+  describe 'auto conversion' do
+    describe 'R-object receive a method' do
+      subject { R.eval_R("c(5,6)") }
+      it      { should == [5,6] }
+      it      { should be_include 5 }
+    end
+
+    describe 'Ruby-object receive a method with R-object' do
+      subject { [5,6].include? R.eval_R("6") }
+      it      { should be_true }
+    end
+  end
+
+  describe '#method_missing' do
+    context 'c(1,2,3)' do
+      let(:obj) { R.eval_R("c(1,2,3)") }
+
+      describe '+ 100' do
+        subject { obj + 100 }
+        it      { should == [101, 102, 103] }
+      end
+
+      describe '- 100' do
+        subject { obj - 100 }
+        it      { should == [-99, -98, -97] }
+      end
+
+      describe '* 100' do
+        subject { obj * 100 }
+        it      { should == [100, 200, 300] }
+      end
+    end
+
+    context 'call a Ruby-method' do
+      subject    { R.eval_R("999") }
+      its(:to_s) { should == '999.0' }
+    end
+  end
+end