rust 0.4 → 0.10

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

@@ -0,0 +1,195 @@
+require_relative '../rust'
+
+module Rust
+    
+    ##
+    # Represents a data-type that can be loaded from and written to R.
+    
+    class RustDatatype
+        
+        ##
+        # Retrieves the given +variable+ from R and transforms it into the appropriate Ruby counterpart.
+        # To infer the type, it uses the class method #can_pull? of all the RustDatatype classes to check the types
+        # that are compatible with the given R variable (type and class). If more than a candidate is available, the one
+        # with maximum #pull_priority is chosen.
+        
+        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
+        
+        ##
+        # Returns the priority of this type when a #pull_variable operation is performed. Higher priority means that
+        # the type is to be preferred over other candidate types.
+        
+        def self.pull_priority
+            0
+        end
+        
+        ##
+        # Writes the current object in R as +variable_name+.
+        
+        def load_in_r_as(variable_name)
+            raise "Loading #{self.class} in R was not implemented"
+        end
+        
+        ##
+        # EXPERIMENTAL: Do not use
+        
+        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
+        
+        ##
+        # EXPERIMENTAL: Do not use
+        
+        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
+        
+        ##
+        # Returns the hash of the current object.
+        
+        def r_hash
+            self.hash.to_s
+        end
+        
+        private
+        def mirrored_R_variable_name
+            return "rust.mirrored.#{self.object_id}"
+        end
+    end
+    
+    ##
+    # The null value in R
+    
+    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
+    
+    ##
+    # Returns a string with the R representation of this object. Raises an exception for unsupported objects.
+    
+    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,158 @@
+require_relative 'datatype'
+
+module Rust
+    
+    ##
+    # Mirror of the factor type in R.
+    
+    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
+        
+        ##
+        # Creates a new factor given an array of numeric +values+ and symbolic +levels+.
+        
+        def initialize(values, levels)
+            @levels = levels.map { |v| v.to_sym }
+            @values = values
+        end
+        
+        ##
+        # Returns the levels of the factor.
+        
+        def levels
+            @levels
+        end
+        
+        def ==(other)
+            return false unless other.is_a?(Factor)
+            
+            return @levels == other.levels && self.to_a == other.to_a
+        end
+        
+        ##
+        # Returns the value of the +i+-th element in the factor.
+        
+        def [](i)
+            FactorValue.new(@values[i], @levels[@values[i] - 1])
+        end
+        
+        ##
+        # Sets the +value+ of the +i+-th element in the factor. If it is an Integer, the +value+ must be between 1 and 
+        # the number of levels of the factor. +value+ can be either a FactorValue or a String/Symbol.
+        
+        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
+        
+        ##
+        # Returns an array of FactorValue for the values in this factor.
+        
+        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
+    
+    ##
+    # Represents a single value in a factor.
+    
+    class FactorValue
+        
+        ##
+        # Creates a factor with a given +value+ (numeric) and +level+ (symbolic).
+        
+        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,199 @@
+require_relative 'datatype'
+
+module Rust
+    
+    ##
+    # Mirror of the formula type in R.
+    
+    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
+        
+        ##
+        # Creates a new formula with a given +left_part+ (optional) and +right_part+ (as strings). 
+        
+        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
+    
+    ##
+    # Mirror of the call type in R.
+    
+    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
+        
+        ##
+        # Creates a new call with the given +value+ (String).
+        
+        def initialize(value)
+            @value = value
+        end
+        
+        def value
+            @value
+        end
+        
+        def inspect
+            @value
+        end
+    end
+    
+    ##
+    # Mirror of the environment type in R. Currently not supported.
+    
+    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
+    
+    ##
+    # Represents a function call in R. After having set up its name (constructor) and, optionally, its arguments
+    # and options, it can be used the call method to execute it in the R environment.
+    
+    class Function
+        attr_reader     :name
+        attr_reader     :arguments
+        attr_reader     :options
+        
+        ##
+        # Creates a new function with a given +name+.
+        
+        def initialize(name)
+            @function = name
+            @arguments  = Arguments.new
+            @options    = Options.new
+        end
+        
+        ##
+        # Sets the +options+ (Options type) of the function.
+        
+        def options=(options)
+            raise TypeError, "Expected Options" unless options.is_a?(Options)
+            
+            @options = options
+        end
+        
+        ##
+        # Sets the +arguments+ (Arguments type) of the function.
+        
+        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
+        
+        ##
+        # Calls the function in the R environment.
+        
+        def call
+            Rust._eval(self.to_R)
+        end
+    end
+    
+    ##
+    # Represents an R variable.
+    
+    class Variable
+        ##
+        # Creates a variable with the given +name+.
+        
+        def initialize(name)
+            @name = name
+        end
+        
+        def to_R
+            @name
+        end
+    end
+    
+    ##
+    # Represents the arguments of a function in R. Works as an Array of objects.
+    
+    class Arguments < Array
+        def to_R
+            return self.map { |v| v.to_R }.join(", ")
+        end
+    end
+    
+    ##
+    # Represents the options of a function in R. Works as a Hash associating option names to objects.
+    
+    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,97 @@
+require_relative 'datatype'
+
+module Rust
+    
+    ##
+    # Mirror of the list type in R.
+    
+    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
+        
+        ##
+        # Creates an empty list of a given class (+klass+) and the specified +names+.
+        
+        def initialize(klass, names = [])
+            @data = {}
+            @names = names
+            @klass = klass
+        end
+        
+        ##
+        # Returns the elements for the name +key+.
+        
+        def [](key)
+            key = get_key(key)
+            
+            return @data[key]
+        end
+        alias :| :[]
+        
+        ##
+        # Sets the +value+ for name +key+.
+        
+        def []=(key, value)
+            key = get_key(key)
+            
+            return @data[key] = value
+        end
+        
+        ##
+        # Returns the names of the list.
+        
+        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