rust 0.7 → 0.9

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

@@ -0,0 +1,161 @@
+require_relative '../rust'
+
+module Rust
+    class RustDatatype
+        def self.pull_variable(variable, forced_interpreter = nil)
+            r_type = Rust._pull("as.character(typeof(#{variable}))")
+            r_class = Rust._pull("as.character(class(#{variable}))")
+            
+            if forced_interpreter
+                raise ArgumentError, "Expected null or class as forced_interpreter" if forced_interpreter && !forced_interpreter.is_a?(Class)
+                raise ArgumentError, "Class #{forced_interpreter} can not handle type #{r_type}, class #{r_class}" unless forced_interpreter.can_pull?(r_type, r_class)
+                
+                return forced_interpreter.pull_variable(variable, r_type, r_class)
+            end
+            
+            candidates = []
+            ObjectSpace.each_object(Class) do |type|
+                if type < RustDatatype
+                    if type.can_pull?(r_type, r_class)
+                        candidates << type
+                    end
+                end
+            end
+            
+            if candidates.size > 0
+                type = candidates.max_by { |c| c.pull_priority }
+                
+                puts "Using #{type} to pull #{variable}" if Rust.debug?
+                return type.pull_variable(variable, r_type, r_class)
+            else
+                if Rust._pull("length(#{variable})") == 0
+                    return []
+                else
+                    return Rust._pull(variable)
+                end
+            end
+        end
+        
+        def self.pull_priority
+            0
+        end
+        
+        def load_in_r_as(variable_name)
+            raise "Loading #{self.class} in R was not implemented"
+        end
+        
+        def r_mirror_to(other_variable)
+            varname = self.mirrored_R_variable_name
+            
+            Rust._eval("#{varname} = #{other_variable}")
+            Rust["#{varname}.hash"] = self.r_hash
+                        
+            return varname
+        end
+        
+        def r_mirror
+            varname = self.mirrored_R_variable_name
+                        
+            if !Rust._pull("exists(\"#{varname}\")") || Rust._pull("#{varname}.hash") != self.r_hash
+                puts "Loading #{varname}" if Rust.debug?
+                Rust[varname] = self
+                Rust["#{varname}.hash"] = self.r_hash
+            else
+                puts "Using cached value for #{varname}" if Rust.debug?
+            end
+            
+            return varname
+        end
+        
+        def r_hash
+            self.hash.to_s
+        end
+        
+        private
+        def mirrored_R_variable_name
+            return "rust.mirrored.#{self.object_id}"
+        end
+    end
+    
+    class Null < RustDatatype
+        def self.can_pull?(type, klass)
+            return type == "NULL" && klass == "NULL"
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            return nil
+        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
+    
+    def load_in_r_as(variable)
+        Rust._eval("#{variable} <- 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 Symbol
+    def to_R
+        return self.to_s.inspect
+    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

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

@@ -0,0 +1,131 @@
+require_relative 'datatype'
+
+module Rust
+    class Factor < RustDatatype
+        def self.can_pull?(type, klass)
+            return klass == "factor"
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            levels = Rust["levels(#{variable})"]
+            values = Rust["as.integer(#{variable})"]
+            
+            return Factor.new(values, levels)
+        end
+        
+        def load_in_r_as(variable_name)
+            Rust['tmp.levels'] = @levels.map { |v| v.to_s }
+            Rust['tmp.values'] = @values
+            
+            Rust._eval("#{variable_name} <- factor(tmp.values, labels=tmp.levels)")
+        end
+        
+        def initialize(values, levels)
+            @levels = levels.map { |v| v.to_sym }
+            @values = values
+        end
+        
+        def levels
+            @levels
+        end
+        
+        def ==(other)
+            return false unless other.is_a?(Factor)
+            
+            return @levels == other.levels && self.to_a == other.to_a
+        end
+        
+        def [](i)
+            FactorValue.new(@values[i], @levels[@values[i] - 1])
+        end
+        
+        def []=(i, value)
+            raise "The given value is outside the factor bounds" if value.is_a?(Integer) && (value < 1 || value > @levels.size)
+            
+            if value.is_a?(FactorValue)
+                raise "Incompatible factor value, different levels used" unless @levels.include?(value.level) || @levels.index(value.level) + 1 == @value.value
+                value = value.value
+            end
+            
+            if value.is_a?(String) || value.is_a?(Symbol)
+                value = value.to_sym
+                raise "Unsupported value #{value}; expected #{@levels.join(", ")}" unless @levels.include?(value)
+                
+                value = @levels.index(value) + 1
+            end
+            
+            @values[i] = value
+        end
+        
+        def to_a
+            @values.map { |v| FactorValue.new(v, @levels[v - 1]) }
+        end
+        
+        def method_missing(method, *args, &block)
+            raise NoMethodError, "Undefined method #{method} for Factor" if method.to_s.end_with?("!") || method.end_with?("=")
+            
+            self.to_a.method(method).call(*args, &block)
+        end
+        
+        def to_s
+            self.to_a.to_s
+        end
+        
+        def inspect
+            self.to_a.inspect
+        end
+    end
+    
+    class FactorValue
+        def initialize(value, level)
+            @value = value
+            @level = level
+        end
+        
+        def value
+            @value
+        end
+        
+        def level
+            @level
+        end
+        
+        def to_i
+            @value
+        end
+        
+        def to_sym
+            @level
+        end
+        
+        def to_R
+            self.to_i
+        end
+        
+        def inspect
+            @level.inspect
+        end
+        
+        def ==(other)
+            if other.is_a?(FactorValue)
+                @value == other.value && @level == other.level
+            elsif other.is_a?(Integer)
+                @value == other
+            elsif other.is_a?(Symbol)
+                @level == other
+            end
+        end
+        
+        def hash
+            @value.hash + @level.hash
+        end
+        
+        def eql?(other)
+            return self == other
+        end
+        
+        def method_missing(method, *args, &block)
+            @level.method(method).call(*args, &block)
+        end
+    end
+end

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

@@ -0,0 +1,166 @@
+require_relative 'datatype'
+
+module Rust
+    class Formula < RustDatatype
+        def self.can_pull?(type, klass)
+            return klass == "formula" || (klass.is_a?(Array) && klass.include?("formula"))
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            formula_elements = Rust._pull("as.character(#{variable})")
+
+            assert("The number of elements of a formula must be 2 or 3: #{formula_elements} given") { formula_elements.size > 1 && formula_elements.size < 4 }
+            if formula_elements.size == 2
+               return Formula.new(nil, formula_elements[1]) 
+            elsif formula_elements.size == 3
+                return Formula.new(formula_elements[2], formula_elements[1])
+            end
+        end
+        
+        def load_in_r_as(variable_name)
+            Rust._eval("#{variable_name} <- #{self.left_part} ~ #{self.right_part}")
+        end
+        
+        attr_reader     :left_part
+        attr_reader     :right_part
+        
+        def initialize(left_part, right_part)
+            raise ArgumentError, "Expected string" if left_part && !left_part.is_a?(String)
+            raise ArgumentError, "Expected string" if !right_part.is_a?(String)
+            
+            @left_part  = left_part || ""
+            @right_part = right_part
+        end
+        
+        def ==(oth)
+            return false unless oth.is_a?(Formula)
+            
+            return @left_part == oth.left_part && @right_part == oth.right_part
+        end
+        
+        def to_R
+            return "#@left_part ~ #@right_part"
+        end
+        
+        def inspect
+            return self.to_R.strip
+        end
+    end
+        
+    class Call < RustDatatype
+        def self.can_pull?(type, klass)
+            return klass == "call"
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            return Call.new(Rust["deparse(#{variable})"])
+        end
+        
+        def load_in_r_as(variable_name)
+            Rust["call.str"] = @value
+            Rust._eval("#{variable_name} <- str2lang(call.str)")
+        end
+        
+        def initialize(value)
+            @value = value
+        end
+        
+        def value
+            @value
+        end
+        
+        def inspect
+            @value
+        end
+    end
+    
+    class Environment < RustDatatype
+        def self.can_pull?(type, klass)
+            return type == "environment" && klass == "environment"
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            warn "Exchanging R environments is not supported!"
+            return Environment.new
+        end
+        
+        def self.load_in_r_as(variable)
+            warn "Exchanging R environments is not supported!"
+            Rust._eval("#{variable} <- environment()")
+        end
+    end
+    
+    class Function
+        attr_reader     :name
+        attr_reader     :arguments
+        attr_reader     :options
+        
+        def initialize(name)
+            @function = name
+            @arguments  = Arguments.new
+            @options    = Options.new
+        end
+        
+        def options=(options)
+            raise TypeError, "Expected Options" unless options.is_a?(Options)
+            
+            @options = options
+        end
+        
+        def arguments=(arguments)
+            raise TypeError, "Expected Arguments" unless options.is_a?(Arguments)
+            
+            @arguments = arguments
+        end
+        
+        def to_R
+            params = [@arguments.to_R, @options.to_R].select { |v| v != "" }.join(",")
+            return "#@function(#{params})"
+        end
+        
+        def call
+            Rust._eval(self.to_R)
+        end
+    end
+    
+    class SimpleFormula
+        def initialize(dependent, independent)
+            @dependent = dependent
+            @independent = independent
+        end
+        
+        def to_R
+            return "#@dependent ~ #@independent"
+        end
+    end
+    
+    class Variable
+        def initialize(name)
+            @name = name
+        end
+        
+        def to_R
+            @name
+        end
+    end
+    
+    class Arguments < Array
+        def to_R
+            return self.map { |v| v.to_R }.join(", ")
+        end
+    end
+    
+    class Options < Hash
+        def to_R
+            return self.map { |k, v| "#{k}=#{v.to_R}" }.join(", ")
+        end
+        
+        def self.from_hash(hash)
+            options = Options.new
+            hash.each do |key, value|
+                options[key.to_s] = value
+            end
+            return options
+        end
+    end
+end 

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

@@ -0,0 +1,81 @@
+require_relative 'datatype'
+
+module Rust
+    class List < RustDatatype
+        def self.can_pull?(type, klass)
+            return type == "list"
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            return List.new(klass) if Rust._pull("length(#{variable})") == 0
+            
+            names    = [Rust["names(#{variable})"]].flatten
+            length   = Rust["length(#{variable})"]
+            
+            list = List.new(klass, names)
+            for i in 0...length
+                list[i] = Rust["#{variable}[[#{i + 1}]]"]
+            end
+            
+            return list
+        end
+        
+        def load_in_r_as(variable_name)
+            Rust._eval("#{variable_name} <- list()")
+            @data.each do |key, value|
+                Rust["#{variable_name}[[#{key + 1}]]"] = value
+            end
+        end
+        
+        def initialize(klass, names = [])
+            @data = {}
+            @names = names
+            @klass = klass
+        end
+        
+        def [](key)
+            key = get_key(key)
+            
+            return @data[key]
+        end
+        alias :| :[]
+        
+        def []=(key, value)
+            key = get_key(key)
+            
+            return @data[key] = value
+        end
+        
+        def names
+            @names
+        end
+        
+        def inspect
+            result = ""
+            values_inspected = @data.map { |k, v| [k, v.inspect.split("\n").map { |l| "  " + l }.join("\n")] }.to_h
+            max_length = [values_inspected.map { |k, v| v.split("\n").map { |line| line.length }.max.to_i }.max.to_i, 100].min
+            
+            @data.keys.each do |i|
+                result << "-" * max_length + "\n"
+                result << (@names[i] || "[[#{i}]]") + "\n"
+                result << values_inspected[i] + "\n"
+            end
+            result << "-" * max_length
+            
+            return result
+        end
+        
+        private
+        def get_key(key)
+            if key.is_a?(String)
+                new_key = @names.index(key)
+                raise ArgumentError, "Wrong key: #{key}" unless new_key
+                key = new_key
+            end
+            
+            raise ArgumentError, "The key should be either a string or an integer" unless key.is_a?(Integer)
+            
+            return key
+        end
+    end
+end

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

@@ -0,0 +1,132 @@
+require_relative 'datatype'
+
+module Rust
+    class Matrix < RustDatatype
+        def self.can_pull?(type, klass)
+            return klass.is_a?(Array) && klass.include?("matrix")
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            if Rust._pull("length(#{variable})") == 1
+                core = ::Matrix[[Rust._pull("#{variable}[1]")]]
+            else
+                core = Rust._pull(variable)
+            end
+            row_names = [Rust["rownames(#{variable})"]].flatten
+            column_names = [Rust["colnames(#{variable})"]].flatten
+            
+            row_names = nil if row_names.all? { |v| v == nil }
+            column_names = nil if column_names.all? { |v| v == nil }
+            
+            Matrix.new(core, row_names, column_names)
+        end
+        
+        def load_in_r_as(variable_name)
+            matrix = ::Matrix[*@data]
+            
+            Rust[variable_name] = matrix
+        end
+        
+        def initialize(data, row_names = nil, column_names = nil)
+            @data = data.clone
+            
+            @row_names = row_names
+            @column_names = column_names
+            
+            if @data.is_a?(::Matrix)
+                @data = @data.row_vectors.map { |v| v.to_a }
+            end
+            
+            if self.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 self.flatten.all? { |e| e.is_a?(Numeric) }
+                raise "All the rows must have the same size" unless @data.map { |row| row.size }.uniq.size == 1
+                raise ArgumentError, "Expected row names #@row_names to match the number of rows in #{self.inspect}" if @row_names && @row_names.size != self.rows
+                raise ArgumentError, "Expected column names #@column_names to match the number of columns in #{self.inspect}" if @column_names && @column_names.size != self.cols
+            end
+        end
+        
+        def [](i, j)
+            i, j = indices(i, j)
+            
+            return @data[i][j]
+        end
+        
+        def rows
+            @data.size
+        end
+        
+        def cols
+            @data[0].size
+        end
+        
+        def flatten
+            return @data.flatten
+        end
+        
+        def []=(i, j, value)
+            i, j = indices(i, j)
+            
+            @data[i][j] = value
+        end
+        
+        def inspect
+            row_names = @row_names || (0...self.rows).to_a.map { |v| v.to_s }
+            column_names = @column_names || (0...self.cols).to_a.map { |v| v.to_s }
+            
+            separator = " | "
+            col_widths = column_names.map do |colname| 
+                [
+                    colname, 
+                    (
+                        [colname ? colname.length : 1] + 
+                        @data.map {|r| r[column_names.index(colname)]}.map { |e| e.inspect.length }
+                    ).max
+                ]
+            end.to_h
+            col_widths[:rowscol] = row_names.map { |rowname| rowname.length }.max + 3
+            
+            result = ""
+            result << "-" * (col_widths.values.sum + ((col_widths.size - 1) * separator.length)) + "\n"
+            result << (" " * col_widths[:rowscol]) + column_names.map { |colname| (" " * (col_widths[colname] - colname.length)) + colname }.join(separator) + "\n"
+            result << "-" * (col_widths.values.sum + ((col_widths.size - 1) * separator.length)) + "\n"
+            
+            @data.each_with_index do |row, i|
+                row_name = row_names[i]
+                row = column_names.zip(row)
+                
+                index_part = "[" + (" " * (col_widths[:rowscol] - row_name.length - 3)) + "#{row_name}] "
+                row_part   = row.map { |colname, value| (" " * (col_widths[colname] - value.inspect.length)) + value.inspect }.join(separator)
+                
+                result << index_part + row_part + "\n"
+            end
+            
+            result << "-" * (col_widths.values.sum + ((col_widths.size - 1) * separator.length))
+            
+            return result
+        end
+        
+        private
+        def indices(i, j)
+            if i.is_a?(String)
+                ri = @row_names.index(i)
+                raise ArgumentError, "Can not find row #{i}" unless ri
+                i = ri
+            end
+            
+            if j.is_a?(String)
+                rj = @column_names.index(j)
+                raise ArgumentError, "Can not find column #{j}" unless rj
+                j = rj
+            end
+            
+            raise ArgumentError, "Expected i and j to be both integers or strings" unless i.is_a?(Integer) && j.is_a?(Integer)
+            raise "Wrong i" unless i.between?(0, @data.size - 1)
+            raise "Wrong j" unless j.between?(0, @data[0].size - 1)
+            
+            return [i, j]
+        end
+    end
+end