rust 0.3 → 0.9

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

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

@@ -0,0 +1,59 @@
+require_relative 'datatype'
+
+module Rust
+    class S4Class < RustDatatype
+        def self.can_pull?(type, klass)
+            return type == "S4"
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            slots = [Rust._pull("names(getSlots(\"#{klass}\"))")].flatten
+            
+            return S4Class.new(variable, klass, slots)
+        end
+        
+        def load_in_r_as(variable_name)
+            Rust._eval("#{variable_name} <- #{self.r_mirror}")
+        end
+        
+        def r_hash
+            "immutable"
+        end
+        
+        def initialize(variable_name, klass, slots)
+            @klass = klass
+            @slots = slots
+            
+            self.r_mirror_to(variable_name)
+        end
+        
+        def [](key)
+            raise ArgumentError, "Unknown slot `#{key}` for class `#@klass`" unless @slots.include?(key)
+            
+            Rust.exclusive do
+                return Rust["#{self.r_mirror}@#{key}"]
+            end
+        end
+        alias :| :[]
+        
+        def []=(key, value)
+            raise ArgumentError, "Unknown slot `#{key}` for class `#@klass`" unless @slots.include?(key)
+            
+            Rust.exclusive do
+                return Rust["#{self.r_mirror}@#{key}"] = value
+            end
+        end
+        
+        def slots
+            @slots
+        end
+        
+        def class_name
+            @klass
+        end
+        
+        def inspect
+            return "<S4 instance of #@klass, with slots #@slots>"
+        end
+    end
+end

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

@@ -0,0 +1,109 @@
+require_relative 'datatype'
+
+module Rust
+    class Sequence < RustDatatype
+        attr_reader :min
+        attr_reader :max
+        
+        def self.can_pull?(type, klass)
+            return false
+        end
+        
+        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 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) #/# <- this comment is just to recover the syntax highlighting bug 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

data/lib/rust/core.rb

@@ -0,0 +1,7 @@
+require_relative 'core/rust'
+require_relative 'core/csv'
+
+self_path = File.expand_path(__FILE__)
+Dir.glob(File.join(File.dirname(self_path), "core/types/*.rb")).each do |lib|
+    require_relative lib
+end

data/lib/rust/models/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