r_type 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8b9fb16ae61ba00a4a815f6989ad52d54c53575b
+  data.tar.gz: 08b5f71abdb66b91646f7e7e45ba17bcd0dd6f24
+SHA512:
+  metadata.gz: 5c53f982491c53dc282091dd5164c1130ddd7e712b9acf6ed27f0a97319086e7f3fe6dd4212c2b80859283d30353b2fe237e70e6a3ac1aae0a40a692041d35f1
+  data.tar.gz: fc1a2cf86d1dae52c686c2870c6510f96a4e02b6580ae591308e1c2ea06527218e116e5ddac1929f73895f66d722666c17c22febd5c1e5a189053a6efccc3f0e

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,14 @@
+env:
+  - R_HOME=/usr/lib/R
+rvm:
+  - 2.0.0
+gemfile:
+  - Gemfile
+branches:
+  only:
+    - master
+before_install:
+ - sudo apt-add-repository -y ppa:marutter/rdev
+ - sudo apt-get update -qq
+ - sudo apt-get install -qq r-base-dev
+ - bundle config build.rsruby --with-R-include=/usr/share/R/include

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+guard 'rspec' do
+  watch %r{^spec/(.+_spec\.rb)$} do |m|
+    "spec/#{m[1]}"
+  end
+
+  watch %r{^lib/r_type/(.+)\.rb$} do |m|
+    "spec/#{m[1]}_spec.rb"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Tatsuya Takamura
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# RType [![Build Status](https://travis-ci.org/ttakamura/robject.png?branch=master)](https://travis-ci.org/ttakamura/robject) [![Dependency Status](https://gemnasium.com/ttakamura/r_type.png)](https://gemnasium.com/ttakamura/r_type)
+
+![r.type image](https://dl.dropboxusercontent.com/u/3111/rtype_1.png)
+
+RType extend RSRuby to be rubyist can use R in a more Ruby way.
+
+RSRuby provide to access R functions and variables from Ruby and basic class conversion.
+And RType provide extended class conversion that convert R class to appropriate Ruby class that has many convenient methods.
+
+## Convert R class to RType
+
+* `matrix` => `RType::Matrix`
+* `numeric` => `RType::Numeric`
+* `vector` => `RType::Vector`
+* `list` => `RType::List`
+* `array` => `RType::Array`
+* `data.frame` => `RType::DataFrame`
+* `character` => `RType::String`
+* other => `RType::Base`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'r_type'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install r_type
+
+## Usage
+
+### Interactive Console
+
+Execute `r_console` to open interactive RType console.
+
+```sh
+r_console
+
+> m = matrix (1..9).to_a, ncol: 3
+=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
+
+> print m * m
+     [,1] [,2] [,3]
+[1,]   30   66  102
+[2,]   36   81  126
+[3,]   42   96  150
+```
+
+### Use RType in your Ruby Class
+
+* Simple script
+
+```ruby
+a = RType::Matrix.new [1,2,3, 4,5,6], ncol: 2
+b = RType::Matrix.new [10, 100], ncol: 1
+
+RType::R.print a * b
+
+#      [,1]
+# [1,]  410
+# [2,]  520
+# [3,]  630
+```
+
+When you haven't define `::R` constant in your code, RType define `::R` as alias of `RType::R`. So, you can write following code.
+
+```ruby
+a = R::Matrix.new [1,2,3, 4,5,6], ncol: 2
+b = R::Matrix.new [10, 100], ncol: 1
+
+R.print a * b
+```
+
+
+* In `RType::R` context
+
+`R.run` call given block in `RType::R` context.
+
+```ruby
+R.run do
+  a = matrix [1,2,3, 4,5,6], ncol: 2
+  b = matrix [10, 100], ncol: 1
+  print a * b
+end
+
+#      [,1]
+# [1,]  410
+# [2,]  520
+# [3,]  630
+```
+
+
+* Assign a variable from Ruby and use it in R
+
+Call `RType::R.eval_R` with a string that has R code.
+
+```ruby
+# assign a value from Ruby
+R.hoge = [1,2,3,4,5]
+
+# eval R code
+R.eval_R <<RTEXT
+  f = function(x) x * 100
+  result = sapply(hoge, f)
+  print(result)
+RTEXT
+```
+
+Or, you can use inline eval_R when `RType::R` context.
+
+```ruby
+R.run do
+  hoge = [1,2,3,4,5]
+  result = sapply hoge, `function(x) x * 100`
+  print result
+end
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+task :default => [:spec]
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['-cfs']
+end

data/bin/r_console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../lib/r_type', __FILE__)
+
+begin
+  require 'pry'
+rescue LoadError => e
+  puts "Can't find the Pry gem!"
+  puts "Please execute 'gem install pry' to use r_console"
+  exit 1
+end
+
+RType::R.run do
+  Pry.start binding, print: ->(output, value) do
+    value.to_ruby if value.respond_to?(:to_ruby)
+    output.puts "=> #{value.inspect}"
+  end
+end

data/lib/r_type.rb

@@ -0,0 +1,41 @@
+require 'rsruby'
+require 'delegate'
+require 'matrix'
+require File.expand_path('../r_type/version', __FILE__)
+require File.expand_path('../r_type/helper', __FILE__)
+require File.expand_path('../r_type/helper/ruby_compareable', __FILE__)
+require File.expand_path('../r_type/helper/matrix_multiply', __FILE__)
+require File.expand_path('../r_type/helper/robj_delegatable_class_methods', __FILE__)
+require File.expand_path('../r_type/core_ext/delegate_checker', __FILE__)
+require File.expand_path('../r_type/core_ext/numeric_delegate_r', __FILE__)
+require File.expand_path('../r_type/core_ext/boolean_delegate_r', __FILE__)
+require File.expand_path('../r_type/helper/robj_delegatable', __FILE__)
+require File.expand_path('../r_type/r', __FILE__)
+require File.expand_path('../r_type/type/base', __FILE__)
+require File.expand_path('../r_type/convert', __FILE__)
+require File.expand_path('../r_type/type/matrix', __FILE__)
+require File.expand_path('../r_type/type/vector', __FILE__)
+require File.expand_path('../r_type/type/numeric', __FILE__)
+require File.expand_path('../r_type/type/integer', __FILE__)
+require File.expand_path('../r_type/type/string', __FILE__)
+require File.expand_path('../r_type/type/list', __FILE__)
+require File.expand_path('../r_type/type/array', __FILE__)
+require File.expand_path('../r_type/type/data_frame', __FILE__)
+require File.expand_path('../r_type/type/function', __FILE__)
+require File.expand_path('../r_type/core_ext', __FILE__)
+
+module RType
+end
+
+unless defined?(::R)
+  ::R = RType::R
+  ::R::Array     = RType::Array
+  ::R::List      = RType::List
+  ::R::Integer   = RType::Integer
+  ::R::Function  = RType::Function
+  ::R::DataFrame = RType::DataFrame
+  ::R::Matrix    = RType::Matrix
+  ::R::Numeric   = RType::Numeric
+  ::R::String    = RType::String
+  ::R::Vector    = RType::Vector
+end

data/lib/r_type/convert.rb

@@ -0,0 +1,28 @@
+module RType
+  class Convert
+    class NotSupportTypeError < Exception; end
+
+    def self.call_R_without_convert func, *args
+      original_mode = RSRuby.get_default_mode
+      RSRuby.set_default_mode RSRuby::BASIC_CONVERSION
+      result = R.rsruby[func].call(*args)
+    ensure
+      RSRuby.set_default_mode original_mode
+      result
+    end
+
+    def convert robj
+      type = check_R_type robj
+      [Function, DataFrame, List, Array, Matrix, String, Vector, Integer, Numeric, Base].each do |klass|
+        if klass.match? robj, type
+          break klass.new robj
+        end
+      end
+    end
+
+    private
+    def check_R_type robj
+      Convert.call_R_without_convert :class, robj
+    end
+  end
+end

data/lib/r_type/core_ext.rb

@@ -0,0 +1,30 @@
+Fixnum.class_eval do
+  prepend RType::CoreExt::NumericDelegateR
+  prepend RType::CoreExt::BooleanDelegateR
+  prepend RType::CoreExt::DelegateChecker
+end
+
+Bignum.class_eval do
+  prepend RType::CoreExt::NumericDelegateR
+  prepend RType::CoreExt::BooleanDelegateR
+  prepend RType::CoreExt::DelegateChecker
+end
+
+Float.class_eval do
+  prepend RType::CoreExt::NumericDelegateR
+  prepend RType::CoreExt::BooleanDelegateR
+  prepend RType::CoreExt::DelegateChecker
+end
+
+Array.class_eval do
+  prepend RType::CoreExt::NumericDelegateR
+  prepend RType::CoreExt::BooleanDelegateR
+  prepend RType::CoreExt::DelegateChecker
+  include RType::Helper::MatrixMultiply
+end
+
+::Matrix.class_eval do
+  def as_r
+    ::RType::R.rbind(*self.to_a)
+  end
+end

data/lib/r_type/core_ext/boolean_delegate_r.rb

@@ -0,0 +1,8 @@
+module RType::CoreExt
+  module BooleanDelegateR
+    extend RType::Helper::RObjDelegatable::ClassMethods
+
+    delegate_to_R '=~' => '=='
+    delegate_to_R '>', '<', '>=', '<=', '|', '&'
+  end
+end

data/lib/r_type/core_ext/delegate_checker.rb

@@ -0,0 +1,11 @@
+module RType::CoreExt
+  module DelegateChecker
+    def is_robj_matrix? val
+      val.is_a?(RType::Vector) || val.is_a?(RType::Matrix)
+    end
+
+    def can_delegate_to_R? *args
+      is_robj_matrix? args.first
+    end
+  end
+end

data/lib/r_type/core_ext/numeric_delegate_r.rb

@@ -0,0 +1,20 @@
+module RType::CoreExt
+  module NumericDelegateR
+    extend RType::Helper::RObjDelegatable::ClassMethods
+
+    delegate_to_R '+', '-', '/', '**', '^'
+
+    def * val
+      if is_robj_matrix?(val)
+        if val.respond_to?(:is_robj_matrix_multiply?) && val.is_robj_matrix_multiply? &&
+            self.respond_to?(:is_robj_matrix_multiply?) && self.is_robj_matrix_multiply?
+          R['%*%'].call(self, val)
+        else
+          R[:*].call(self, val)
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/r_type/helper.rb

@@ -0,0 +1,4 @@
+module RType
+  module Helper
+  end
+end

data/lib/r_type/helper/matrix_multiply.rb

@@ -0,0 +1,13 @@
+module RType::Helper::MatrixMultiply
+  def * val
+    if val.respond_to?(:is_robj_matrix_multiply?) && val.is_robj_matrix_multiply?
+      R['%*%'].call self, val
+    else
+      super
+    end
+  end
+
+  def is_robj_matrix_multiply?
+    true
+  end
+end

data/lib/r_type/helper/robj_delegatable.rb

@@ -0,0 +1,78 @@
+module RType
+  module Helper
+    module RObjDelegatable
+      extend ClassMethods
+      include RType::CoreExt::NumericDelegateR
+      include RType::CoreExt::BooleanDelegateR
+
+      delegate_to_R '*'
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      def __getobj__
+        to_ruby
+      end
+
+      def robj
+        @robj ||= convert_ruby_to_robj.tap do |newobj|
+          @ruby_obj = nil unless newobj.nil?
+        end
+      end
+
+      def ruby_obj
+        @ruby_obj ||= convert_robj_to_ruby.tap do |newobj|
+          @robj = nil unless newobj.nil?
+        end
+      end
+
+      def robj= obj
+        @ruby_obj = nil
+        @robj = obj
+      end
+
+      def ruby_obj= obj
+        @robj = nil
+        @ruby_obj = obj
+      end
+
+      def as_r
+        robj.as_r
+      end
+
+      def to_ruby mode = nil
+        ruby_obj
+      end
+
+      def inspect
+        "RType::#{(@robj || @ruby_obj).inspect}"
+      end
+
+      def == obj
+        if obj.is_a?(RObjDelegatable)
+          self.robj == obj.robj || !!R['identical'].call(self, obj)
+        else
+          super
+        end
+      end
+
+      private
+      def convert_robj_to_ruby
+        @robj.to_ruby(::RSRuby::BASIC_CONVERSION)
+      end
+
+      def convert_ruby_to_robj
+        if @ruby_obj.respond_to?(:as_r)
+          @ruby_obj.as_r.robj
+        else
+          R.assign('_tmp_var_for_rtype', @ruby_obj).robj
+        end
+      end
+
+      def can_delegate_to_R? *args
+        true
+      end
+    end
+  end
+end