r_type 0.0.3

data/lib/r_type/helper/robj_delegatable_class_methods.rb

@@ -0,0 +1,35 @@
+module RType
+  module Helper
+    module RObjDelegatable
+      module ClassMethods
+        def delegate_to_R *from_to
+          from_to_hash = from_to.first.is_a?(Hash) \
+                           ? from_to.first         \
+                           : from_to.inject({}) {|h,x| h[x] = x; h }
+
+          from_to_hash.each do |from, to|
+            define_method(from) do |*args, &block|
+              if can_delegate_to_R?(*args)
+                R[to].call(self, args.first)
+              else
+                super(*args, &block)
+              end
+            end
+          end
+        end
+
+        def delegate_constructor klass, *methods
+          delegate_klass = self
+
+          methods.each do |name|
+            self.class.class_eval do
+              define_method(name) do |*args, &block|
+                delegate_klass.new klass.send(name, *args, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r_type/helper/ruby_compareable.rb

@@ -0,0 +1,9 @@
+module RType::Helper::RubyCompareable
+  def == obj
+    if obj.is_a?(RType::Helper::Compareable)
+      to_ruby == obj.to_ruby
+    else
+      super
+    end
+  end
+end

data/lib/r_type/r.rb

@@ -0,0 +1,50 @@
+module RType
+  module R
+    class << self
+      def method_missing name, *args, &block
+        if name =~ /^(.*)=$/
+          rsruby[:assign].call $1.to_s, args.first
+        elsif rsruby.respond_to? name
+          rsruby.send name, *args
+        else
+          obj = rsruby[name]
+          if obj.is_a?(::RType::Function)
+            obj.call *args
+          else
+            obj
+          end
+        end
+      end
+
+      def run &block
+        instance_eval &block
+      end
+
+      def print *args
+        rsruby[:print].call *args
+      end
+
+      def lazy_expression r_exp
+        rsruby.eval_R "quote(#{r_exp})"
+      end
+      alias_method "`", :lazy_expression
+
+      def rsruby
+        @rsruby ||= init_rsruby
+      end
+
+      def init_rsruby
+        RSRuby.set_default_mode RSRuby::PROC_CONVERSION
+        converter = RType::Convert.new
+        @rsruby = RSRuby.instance
+        @rsruby.proc_table[->(x){ true }] = ->(x) { converter.convert x }
+        @rsruby
+      end
+
+      private
+      def reset
+        @rsruby = nil
+      end
+    end
+  end
+end

data/lib/r_type/type/array.rb

@@ -0,0 +1,7 @@
+module RType
+  class Array < Base
+    def self.match? robj, type
+      type == 'array'
+    end
+  end
+end

data/lib/r_type/type/base.rb

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+module RType
+  class Base < DelegateClass(RObj)
+    include Helper::RObjDelegatable
+
+    def self.match? robj, type
+      true
+    end
+
+    def initialize robj
+      @robj = robj
+    end
+  end
+end

data/lib/r_type/type/data_frame.rb

@@ -0,0 +1,7 @@
+module RType
+  class DataFrame < Base
+    def self.match? robj, type
+      type == 'data.frame'
+    end
+  end
+end

data/lib/r_type/type/function.rb

@@ -0,0 +1,8 @@
+module RType
+  class Function < Base
+    def self.match? robj, type
+      type == 'function' || (type == 'standardGeneric' &&
+                             Convert.call_R_without_convert(:is_function, robj))
+    end
+  end
+end

data/lib/r_type/type/integer.rb

@@ -0,0 +1,7 @@
+module RType
+  class Integer < Numeric
+    def self.match? robj, type
+      type == 'integer'
+    end
+  end
+end

data/lib/r_type/type/list.rb

@@ -0,0 +1,7 @@
+module RType
+  class List < Base
+    def self.match? robj, type
+      type == 'list'
+    end
+  end
+end

data/lib/r_type/type/matrix.rb

@@ -0,0 +1,65 @@
+module RType
+  class Matrix < DelegateClass(::Matrix)
+    include Helper::RObjDelegatable
+    include Helper::MatrixMultiply
+
+    delegate_constructor ::Matrix, :I, :[], :build, :column_vector, :columns,
+                                   :diagonal, :empty, :identity, :row_vector,
+                                   :rows, :scalar, :unit, :zero
+
+    def self.match? robj, type
+      type == 'matrix'
+    end
+
+    def initialize obj, *args
+      case obj
+      when ::RObj
+        @robj = obj
+      when ::Matrix
+        @ruby_obj = obj
+      else
+        raise "Not supported: #{obj} in RType::Matrix"
+      end
+    end
+
+    def [] *args
+      args = convert_nil_args_to_vector(args)
+      R['['].call self, *args
+    end
+
+    def []= *args
+      if args[0].is_a?(RType::Matrix)
+        self.robj = R['[<-'].call(self, args[0], args[1]).robj
+      else
+        args = convert_nil_args_to_vector(args)
+        self.robj = R['[<-'].call(self, *args).robj
+      end
+    end
+
+    def row_size
+      R.nrow(self)
+    end
+
+    def column_size
+      R.ncol(self)
+    end
+
+    private
+    def convert_robj_to_ruby
+      if R.mode(self) == 'logical'
+        # We can't parse this R-matrix. So, we return robj instead of ruby_obj.
+        # TODO: Parse R-matrix that have logical values
+        nil
+      else
+        rows = super
+        ::Matrix.rows(rows.first.is_a?(::Numeric) ? [rows] : rows)
+      end
+    end
+
+    def convert_nil_args_to_vector args
+      args[0] = (1..row_size).to_a    if args[0].nil? && args[1].is_a?(::Numeric)
+      args[1] = (1..column_size).to_a if args[1].nil? && args[0].is_a?(::Numeric)
+      args
+    end
+  end
+end

data/lib/r_type/type/numeric.rb

@@ -0,0 +1,7 @@
+module RType
+  class Numeric < Base
+    def self.match? robj, type
+      type == 'numeric'
+    end
+  end
+end

data/lib/r_type/type/string.rb

@@ -0,0 +1,7 @@
+module RType
+  class String < Base
+    def self.match? robj, type
+      type == 'character'
+    end
+  end
+end

data/lib/r_type/type/vector.rb

@@ -0,0 +1,10 @@
+module RType
+  class Vector < Base
+    include Helper::MatrixMultiply
+
+    def self.match? robj, type
+      (type == 'numeric' || type == 'integer') &&
+        Convert.call_R_without_convert(:length, robj) > 1
+    end
+  end
+end

data/lib/r_type/version.rb

@@ -0,0 +1,3 @@
+module RType
+  VERSION = "0.0.3"
+end

data/r_type.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'r_type/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "r_type"
+  spec.version       = RType::VERSION
+  spec.authors       = ["Tatsuya Takamura"]
+  spec.email         = ["tkmr2000@gmail.com"]
+  spec.description   = %q{RType is a wrapper library for RSRuby.}
+  spec.summary       = %q{RType is a wrapper library for RSRuby.}
+  spec.homepage      = "https://github.com/ttakamura"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rsruby", ">= 0.5"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.13.0"
+  spec.add_development_dependency "rspec-mocks", "~> 2.13.0"
+  spec.add_development_dependency "guard", "~> 1.8.0"
+  spec.add_development_dependency "guard-rspec", "~> 3.0.1"
+end

data/sample/sample1.rb

@@ -0,0 +1,34 @@
+require '../lib/r_type'
+
+R.run do
+  print (cos(0) - sqrt(2)) / exp(4)
+
+  x = (1..5).to_a
+  print sqrt(x)
+  print log(x)
+
+  self.x2 = [1, 2, 3, 4, 5, 3]
+  self.y2 = [1, 3, 2, 4, 5, 3]
+  print summary(x2)
+  print cor(x2, y2)
+  print diff(y2)
+  print cumsum(x2)
+
+  print x2 + y2
+  print x2 - y2
+  print x2 + 10
+  print x2 * y2
+end
+# >> [1] -0.007586586
+# >> [1] 1.000000 1.414214 1.732051 2.000000 2.236068
+# >> [1] 0.0000000 0.6931472 1.0986123 1.3862944 1.6094379
+# >>    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+# >>    1.00    2.25    3.00    3.00    3.75    5.00
+# >> [1] 0.9
+# >> [1]  2 -1  2  1 -2
+# >> [1]  1  3  6 10 15 18
+# >> [1]  2  5  5  8 10  6
+# >> [1]  0 -1  1  0  0  0
+# >> [1] 11 12 13 14 15 13
+# >>      [,1]
+# >> [1,]   63

data/sample/sample2.rb

@@ -0,0 +1,38 @@
+require '../lib/r_type'
+
+R.run do
+  x = (0..4).to_a
+
+  double = eval_R <<-RSRC
+    function (x) x * 2
+  RSRC
+
+  print double(10)
+  print sapply(x, double)
+  pow = `function(x) x ^ 2`
+  print sapply(x, pow)
+
+  f = `function(x) exp(x) - 2`
+  print uniroot(f, [0, 1])
+
+  print polyroot([2, 3, 1])
+  print integrate(pow, 0, 1)
+end
+# >>  [1] 0 0 0 0 0 0 0 0 0 0
+# >> [1] 0 2 4 6 8
+# >> [1]  0  1  4  9 16
+# >> $root
+# >> [1] 0.6931457
+# >>
+# >> $f.root
+# >> [1] -2.943424e-06
+# >>
+# >> $iter
+# >> [1] 5
+# >>
+# >> $estim.prec
+# >> [1] 6.103516e-05
+# >>
+# >> [1] -1+0i -2-0i
+# >> 0.3333333 with absolute error < 3.7e-15
+# >> 0.9772499 with absolute error < 1.6e-06

data/sample/sample3.rb

@@ -0,0 +1,79 @@
+require '../lib/r_type'
+
+R.run do
+  print RType::Matrix.zero 3
+  print RType::Matrix.I 3
+
+  a = RType::Matrix[[1, 3], [2, 4]]
+  b = RType::Matrix[[0, 2], [1, 3]]
+
+  print t(a)
+  print a + b - a * b
+
+  print outer(a, b)
+  print kronecker(a, b)
+
+  print a * [1, 2]
+  print 1 / a
+
+  x = matrix (1..9).to_a, ncol: 3
+  print upper_tri(x)
+  print x
+end
+# >>      [,1] [,2] [,3]
+# >> [1,]    0    0    0
+# >> [2,]    0    0    0
+# >> [3,]    0    0    0
+# >>      [,1] [,2] [,3]
+# >> [1,]    1    0    0
+# >> [2,]    0    1    0
+# >> [3,]    0    0    1
+# >>      [,1] [,2]
+# >> [1,]    1    2
+# >> [2,]    3    4
+# >>      [,1] [,2]
+# >> [1,]   -2   -6
+# >> [2,]   -1   -9
+# >> , , 1, 1
+# >>
+# >>      [,1] [,2]
+# >> [1,]    0    0
+# >> [2,]    0    0
+# >>
+# >> , , 2, 1
+# >>
+# >>      [,1] [,2]
+# >> [1,]    1    3
+# >> [2,]    2    4
+# >>
+# >> , , 1, 2
+# >>
+# >>      [,1] [,2]
+# >> [1,]    2    6
+# >> [2,]    4    8
+# >>
+# >> , , 2, 2
+# >>
+# >>      [,1] [,2]
+# >> [1,]    3    9
+# >> [2,]    6   12
+# >>
+# >>      [,1] [,2] [,3] [,4]
+# >> [1,]    0    2    0    6
+# >> [2,]    1    3    3    9
+# >> [3,]    0    4    0    8
+# >> [4,]    2    6    4   12
+# >>      [,1]
+# >> [1,]    7
+# >> [2,]   10
+# >>      [,1]      [,2]
+# >> [1,]  1.0 0.3333333
+# >> [2,]  0.5 0.2500000
+# >>       [,1]  [,2]  [,3]
+# >> [1,] FALSE  TRUE  TRUE
+# >> [2,] FALSE FALSE  TRUE
+# >> [3,] FALSE FALSE FALSE
+# >>      [,1] [,2] [,3]
+# >> [1,]    1    4    7
+# >> [2,]    2    5    8
+# >> [3,]    3    6    9