rust 0.7 → 0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35c41ec98f5b286ef597096152249f19825a27bc33030e85ea196df8b778d3b1
-  data.tar.gz: 48b2e61f707ebcd05fa5f593016c8c0fb4b9d1e58751dd5deae83715583bd978
+  metadata.gz: aaa404db11033ff42b529516ae4a3f3e252bdddf7677d082847ee06625144f8e
+  data.tar.gz: f72ebc2c95385b87a445f3fb8de3e517579b002e0606209903acd2327616befd
 SHA512:
-  metadata.gz: b0cc1289721d52cd376e0a242c2be419ea511f03a0fdd42c4c7a1973cde24e8dfc467e9d355693f85632cccb98af6986777aa020b715db5f06aa88a63d154ea0
-  data.tar.gz: 4c91c808773dcd04913a594cfcaa7956318908e6d590ebec1d9a04beef18986adc70a3c5e480c39bdc9f753b5edf920a1939208b8b530ccfc67124ac153a4804
+  metadata.gz: 00567c9b6216f7e9dc1a4135dbea263eecae2178273851c023980233531729313e15147e1bec8e9521df2d4fee15e2c4c8bf9bd4a0e2d1475f1d383339a17c21
+  data.tar.gz: 89800fff95be559e6f6bbbc05b6b5f5b52b7d59c54c61cd76ef679876ce5de0c08b405d88eadf0b254c95306ad98f38120e5960a92ce8358fca19ed6cc5c181d

data/bin/ruby-rust

@@ -0,0 +1,3 @@
+#!/usr/bin/ruby
+
+system "irb -r \"rust\""

data/lib/{rust-csv.rb → rust/core/csv.rb}

@@ -1,4 +1,5 @@
-require_relative 'rust-core'
+require_relative '../core'
+require 'csv'
 
 module Rust
     class CSV

data/lib/rust/core/rust.rb

@@ -0,0 +1,157 @@
+require 'code-assertions'
+require 'stringio'
+require 'rinruby'
+
+module Rust
+    CLIENT_MUTEX = Mutex.new
+    R_MUTEX      = Mutex.new
+    
+    R_ENGINE     = RinRuby.new(echo: false)
+    
+    private_constant    :R_ENGINE
+    private_constant    :R_MUTEX
+    private_constant    :CLIENT_MUTEX
+    
+    @@debugging = $RUST_DEBUG || false
+    @@in_client_mutex = false
+    
+    def self.debug
+        @@debugging = true
+    end
+    
+    def self.debug?
+        return @@debugging
+    end
+    
+    def self.exclusive
+        result = nil
+        CLIENT_MUTEX.synchronize do
+            @@in_client_mutex = true
+            result = yield
+            @@in_client_mutex = false
+        end
+        return result
+    end
+    
+    def self.[]=(variable, value)
+        if value.is_a?(RustDatatype)
+            value.load_in_r_as(variable.to_s)
+        elsif value.is_a?(String) || value.is_a?(Numeric) || value.is_a?(Array) || value.is_a?(::Matrix)
+            R_ENGINE.assign(variable, value)
+        else
+            raise "Trying to assign #{variable} with #{value.class}; expected RustDatatype, String, Numeric, or Array"
+        end
+        
+    end
+    
+    def self.[](variable)
+        return RustDatatype.pull_variable(variable)
+    end
+    
+    def self._eval_big(r_command, return_warnings = false)
+        r_command = r_command.join("\n") if r_command.is_a?(Array)
+        
+        self._rexec(r_command, return_warnings) do |cmd|
+            result = true
+            instructions = cmd.lines
+            
+            while instructions.size > 0
+                current_command = ""
+                
+                while (instructions.size > 0) && (current_command.length + instructions.first.length < 10000)
+                    current_command << instructions.shift
+                end
+                
+                result &= R_ENGINE.eval(current_command)
+            end
+            
+            result
+        end
+    end
+    
+    def self._pull(r_command, return_warnings = false)
+        self._rexec(r_command, return_warnings) { |cmd| R_ENGINE.pull(cmd) }
+    end
+    
+    def self._eval(r_command, return_warnings = false)
+        self._rexec(r_command, return_warnings) { |cmd| R_ENGINE.eval(cmd) }
+    end
+    
+    def self._rexec(r_command, return_warnings = false)
+        puts "Calling _rexec with command: #{r_command}" if @@debugging
+        R_MUTEX.synchronize do
+            assert("This command must be executed in an exclusive block") { @@in_client_mutex }
+            
+            result = nil
+            begin
+                $stdout = StringIO.new
+                if return_warnings
+                    R_ENGINE.echo(true, true)
+                else
+                    R_ENGINE.echo(false, false)
+                end
+                result = yield(r_command)
+            ensure
+                R_ENGINE.echo(false, false)
+                warnings = $stdout.string
+                $stdout = STDOUT
+            end
+            
+            if return_warnings
+                puts " Got #{warnings.size} warnings, with result #{result.inspect[0...100]}" if @@debugging
+                return result, warnings.lines.map { |w| w.strip.chomp }
+            else
+                puts " Result: #{result.inspect[0...100]}" if @@debugging
+                return result
+            end
+        end
+    end
+    
+    def self.check_library(name)
+        self.exclusive do
+            result, _ = self._pull("require(\"#{name}\", character.only = TRUE)", true)
+            return result
+        end
+    end
+    
+    def self.load_library(name)
+        self.exclusive do
+            self._eval("library(\"#{name}\", character.only = TRUE)")
+        end
+        
+        return nil
+    end
+    
+    def self.install_library(name)
+        self.exclusive do
+            self._eval("install.packages(\"#{name}\", dependencies = TRUE)")
+        end
+        
+        return nil
+    end
+    
+    def self.prerequisite(library)
+        self.install_library(library) unless self.check_library(library)
+        self.load_library(library)
+    end
+end
+
+module Rust::RBindings
+    def data_frame(*args)
+        Rust::DataFrame.new(*args)
+    end
+end
+
+module Rust::TestCases
+    def self.sample_dataframe(columns, size=100)
+        result = Rust::DataFrame.new(columns)
+        size.times do |i|
+            result << columns.map { |c| yield i, c }
+        end
+        return result
+    end
+end
+
+def bind_r!
+    include Rust::RBindings
+end

data/lib/rust/core/types/all.rb

@@ -0,0 +1,4 @@
+self_path = File.expand_path(__FILE__)
+Dir.glob(File.dirname(self_path) + "/*.rb").each do |lib|
+    require_relative lib unless lib == self_path
+end

data/lib/{rust-core.rb → rust/core/types/dataframe.rb}

@@ -1,123 +1,20 @@
-require 'code-assertions'
-require 'stringio'
-require 'rinruby'
-require 'csv'
+require_relative 'datatype'
 
 module Rust
-    CLIENT_MUTEX = Mutex.new
-    R_MUTEX      = Mutex.new
-    
-    R_ENGINE     = RinRuby.new(echo: false)
-    
-    private_constant    :R_ENGINE
-    private_constant    :R_MUTEX
-    private_constant    :CLIENT_MUTEX
-    
-    @@debugging = false
-    @@in_client_mutex = false
-    
-    def self.debug
-        @@debugging = true
-    end
-    
-    def self.exclusive
-        result = nil
-        CLIENT_MUTEX.synchronize do
-            @@in_client_mutex = true
-            result = yield
-            @@in_client_mutex = false
-        end
-        return result
-    end
-    
-    def self.[]=(variable, value)
-        if value.is_a?(RustDatatype)
-            value.load_in_r_as(variable.to_s)
-        elsif value.is_a?(String) || value.is_a?(Numeric) || value.is_a?(Array)
-            R_ENGINE.assign(variable, value)
-        else
-            raise "Given #{value.class}, expected RustDatatype, String, Numeric, or Array"
+    class DataFrame < RustDatatype
+        def self.can_pull?(type, klass)
+            return [klass].flatten.include?("data.frame")
         end
         
-    end
-    
-    def self.[](variable, type=RustDatatype)
-        return type.pull_variable(variable)
-    end
-    
-    def self._eval_big(r_command, return_warnings = false)
-        r_command = r_command.join("\n") if r_command.is_a?(Array)
-        
-        self._rexec(r_command, return_warnings) do |cmd|
-            result = true
-            instructions = cmd.lines
-            
-            while instructions.size > 0
-                current_command = ""
-                
-                while (instructions.size > 0) && (current_command.length + instructions.first.length < 10000)
-                    current_command << instructions.shift
-                end
-                
-                result &= R_ENGINE.eval(current_command)
-            end
-            
-            result
-        end
-    end
-    
-    def self._pull(r_command, return_warnings = false)
-        self._rexec(r_command, return_warnings) { |cmd| R_ENGINE.pull(cmd) }
-    end
-    
-    def self._eval(r_command, return_warnings = false)
-        self._rexec(r_command, return_warnings) { |cmd| R_ENGINE.eval(cmd) }
-    end
-    
-    def self._rexec(r_command, return_warnings = false)
-        puts "Calling _rexec with command: #{r_command}" if @@debugging
-        R_MUTEX.synchronize do
-            assert("This command must be executed in an exclusive block") { @@in_client_mutex }
-            
-            result = nil
-            begin
-                $stdout = StringIO.new
-                if return_warnings
-                    R_ENGINE.echo(true, true)
-                else
-                    R_ENGINE.echo(false, false)
-                end
-                result = yield(r_command)
-            ensure
-                R_ENGINE.echo(false, false)
-                warnings = $stdout.string
-                $stdout = STDOUT
-            end
-            
-            if return_warnings
-                return result, warnings.lines.map { |w| w.strip.chomp }
-            else
-                return result
-            end
-        end
-    end
-    
-    class RustDatatype
-        def self.pull_variable(variable)
-            return Rust._pull(variable)
+        def self.pull_priority
+            1
         end
         
-        def load_in_r_as(r_instance, variable_name)
-            raise "Not implemented"
-        end
-    end
-    
-    class DataFrame < RustDatatype
-        def self.pull_variable(variable)
+        def self.pull_variable(variable, type, klass)
             hash = {}
-            colnames = Rust._pull("colnames(#{variable})")
+            colnames = Rust["colnames(#{variable})"]
             colnames.each do |col|
-                hash[col] = Rust._pull("#{variable}$#{col}")
+                hash[col] = Rust["#{variable}$\"#{col}\""]
             end
             return DataFrame.new(hash)
         end
@@ -373,6 +270,14 @@ module Rust
                 row_index += 1
             end
             
+            self.column_names.each do |name|
+                column = self.column(name)
+                
+                if column.is_a?(Factor)
+                    command << "#{variable_name}[,#{name.to_R}] <- factor(#{variable_name}[,#{name.to_R}], labels=#{column.levels.to_R})"
+                end
+            end
+            
             Rust._eval_big(command)
         end
         
@@ -586,82 +491,6 @@ module Rust
         end
     end
     
-    class Matrix < RustDatatype
-        def self.pull_variable(variable)
-            return Rust._pull(variable)
-        end
-        
-        def initialize(data)
-            if data.flatten.size == 0
-                raise "Empty matrices are not allowed"
-            else
-                raise TypeError, "Expected array of array" unless data.is_a?(Array) && data[0].is_a?(Array)
-                raise TypeError, "Only numeric matrices are supported" unless data.all? { |row| row.all?  { |e| e.is_a?(Numeric) } }
-                raise "All the rows must have the same size" unless data.map { |row| row.size }.uniq.size == 1
-                @data = data.clone
-            end
-        end
-        
-        def [](i, j)
-            return @data[i][j]
-        end
-        
-        def rows
-            @data.size
-        end
-        
-        def cols
-            @data[0].size
-        end
-        
-        def []=(i, j, value)
-            raise "Wrong i" unless i.between?(0, @data.size - 1)
-            raise "Wrong j" unless j.between?(0, @data[0].size - 1)
-            @data[i][j] = value
-        end
-        
-        def load_in_r_as(variable_name)
-            Rust._eval("#{variable_name} <- matrix(c(#{@data.flatten.join(",")}), nrow=#{self.rows}, ncol=#{self.cols}, byrow=T)")
-        end
-    end
-    
-    class Sequence < RustDatatype
-        attr_reader :min
-        attr_reader :max
-        
-        def initialize(min, max, step=1)
-            @min = min
-            @max = max
-            @step = step
-        end
-        
-        def step(step)
-            @step = step
-        end
-        
-        def each
-            (@min..@max).step(@step) do |v|
-                yield v
-            end
-        end
-        
-        def to_a
-            result = []
-            self.each do |v|
-                result << v
-            end
-            return result
-        end
-        
-        def to_R
-            "seq(from=#@min, to=#@max, by=#@step)"
-        end
-        
-        def load_in_r_as(variable_name)
-            Rust._eval("#{variable_name} <- #{self.to_R}")
-        end
-    end
-    
     class DataFrameArray < Array
         def bind_all
             return nil if self.size == 0
@@ -689,151 +518,4 @@ module Rust
             return result
         end
     end
-    
-    class MathArray < Array
-        def -(other)
-            raise ArgumentError, "Expected array or numeric" if !other.is_a?(::Array) && !other.is_a?(Numeric)
-            raise ArgumentError, "The two arrays must have the same size" if other.is_a?(::Array) && self.size != other.size
-            
-            result = self.clone
-            other = [other] * self.size if other.is_a?(Numeric)
-            for i in 0...self.size
-                result[i] -= other[i]
-            end
-            
-            return result
-        end
-        
-        def *(other)
-            raise ArgumentError, "Expected array or numeric" if !other.is_a?(::Array) && !other.is_a?(Numeric)
-            raise ArgumentError, "The two arrays must have the same size" if other.is_a?(::Array) && self.size != other.size
-            
-            result = self.clone
-            other = [other] * self.size if other.is_a?(Numeric)
-            for i in 0...self.size
-                result[i] *= other[i]
-            end
-            
-            return result
-        end
-                
-        def +(other)
-            raise ArgumentError, "Expected array or numeric" if !other.is_a?(::Array) && !other.is_a?(Numeric)
-            raise ArgumentError, "The two arrays must have the same size" if other.is_a?(::Array) && self.size != other.size
-            
-            result = self.clone
-            other = [other] * self.size if other.is_a?(Numeric)
-            for i in 0...self.size
-                result[i] += other[i]
-            end
-            
-            return result
-        end
-        
-        def /(other) #To recover the syntax highlighting but in Kate: /
-            raise ArgumentError, "Expected array or numeric" if !other.is_a?(::Array) && !other.is_a?(Numeric)
-            raise ArgumentError, "The two arrays must have the same size" if other.is_a?(::Array) && self.size != other.size
-            
-            result = self.clone
-            other = [other] * self.size if other.is_a?(Numeric)
-            for i in 0...self.size
-                result[i] /= other[i]
-            end
-            
-            return result
-        end
-        
-        def **(other)
-            raise ArgumentError, "Expected numeric" if !other.is_a?(Numeric)
-            
-            result = self.clone
-            for i in 0...self.size
-                result[i] = result[i] ** other
-            end
-            
-            return result
-        end
-    end
-end
-
-class TrueClass
-    def to_R
-        "TRUE"
-    end
-end
-
-class FalseClass
-    def to_R
-        "FALSE"
-    end
-end
-
-class Object
-    def to_R
-        raise TypeError, "Unsupported type for #{self.class}"
-    end
-end
-
-class NilClass
-    def to_R
-        return "NULL"
-    end
-end
-
-class Numeric
-    def to_R
-        self.inspect
-    end
-end
-
-class Float
-    def to_R
-        return self.nan? ? "NA" : super
-    end
-end
-
-class Array
-    def to_R
-        return "c(#{self.map { |e| e.to_R }.join(",")})"
-    end
-    
-    def distribution
-        result = {}
-        self.each do |value|
-            result[value] = result[value].to_i + 1
-        end
-        return result
-    end
-end
-
-class String
-    def to_R
-        return self.inspect
-    end
-end
-
-class Range
-    def to_R
-        [range.min, range.max].to_R
-    end
-end
-
-module Rust::RBindings
-    def data_frame(*args)
-        Rust::DataFrame.new(*args)
-    end
-end
-
-module Rust::TestCases
-    def self.sample_dataframe(columns, size=100)
-        result = Rust::DataFrame.new(columns)
-        size.times do |i|
-            result << columns.map { |c| yield i, c }
-        end
-        return result
-    end
-end
-
-def bind_r!
-    include Rust::RBindings
 end