rust 0.4 → 0.10

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

@@ -0,0 +1,155 @@
+require_relative 'datatype'
+
+module Rust
+    
+    ##
+    # Mirror of the matrix type in R.
+    
+    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
+        
+        ##
+        # Creates a new matrix with the given +data+ (Ruby Matrix). Optionally, +row_names+ and +column_names+ can 
+        # be specified.
+        
+        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
+        
+        ##
+        # Returns the matrix element at row +i+ and column +j+.
+        
+        def [](i, j)
+            i, j = indices(i, j)
+            
+            return @data[i][j]
+        end
+        
+        ##
+        # Sets the matrix element at row +i+ and column +j+ with +value+.
+        
+        def []=(i, j, value)
+            i, j = indices(i, j)
+            
+            @data[i][j] = value
+        end
+        
+        ##
+        # Returns the number of rows.
+        
+        def rows
+            @data.size
+        end
+        
+        ##
+        # Returns the number of columns.
+        
+        def cols
+            @data[0].size
+        end
+        
+        ##
+        # Returns a flattened version of the matrix (Array).
+        
+        def flatten
+            return @data.flatten
+        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,78 @@
+require_relative 'datatype'
+
+module Rust
+    
+    ##
+    # Mirror for the S4 class in R.
+    
+    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
+        
+        ##
+        # Creates a new S4 element, given its +variable_name+, class name (+klass+), and +slots+.
+        
+        def initialize(variable_name, klass, slots)
+            @klass = klass
+            @slots = slots
+            
+            self.r_mirror_to(variable_name)
+        end
+        
+        ##
+        # Returns the slot +key+ for the class name (+klass+).
+        
+        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 :| :[]
+        
+        ##
+        # Returns the slot +key+ for the class name (+klass+) with +value+.
+        
+        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
+        
+        ##
+        # Returns the slots.
+        
+        def slots
+            @slots
+        end
+        
+        ##
+        # Returns the class name.
+        
+        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,122 @@
+require_relative 'datatype'
+
+module Rust
+    
+    ##
+    # Represents a sequence of values in R (through a call to the seq function).
+    
+    class Sequence < RustDatatype
+        attr_reader :min
+        attr_reader :max
+        
+        def self.can_pull?(type, klass)
+            return false
+        end
+        
+        ##
+        # Creates a new sequence from +min+ to +max+ with a given +step+ (default = 1).
+        
+        def initialize(min, max, step=1)
+            @min = min
+            @max = max
+            @step = step
+        end
+        
+        ##
+        # Sets the step to +step+.
+        
+        def step=(step)
+            @step = step
+            
+            return self
+        end
+        alias :step :step=
+        
+        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

data/lib/rust/models/anova.rb

@@ -0,0 +1,77 @@
+require_relative '../core'
+
+module Rust
+    
+    ##
+    # Mirror for an ANOVA model type in R. To create a new ANOVA model (aov), call the #generate method.
+    
+    class ANOVAModel < RustDatatype
+        def self.can_pull?(type, klass)
+            return type == "list" && [klass].flatten.include?("aov")
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            model = RustDatatype.pull_variable(variable, Rust::List)
+            
+            return ANOVAModel.new(model)
+        end
+        
+        def load_in_r_as(variable_name)
+            @model.load_in_r_as(variable_name)
+        end
+        
+        ##
+        # Generates a new ANOVA model with a given +formula+, +data+. +options+ can be specified and directly passed
+        # to the aov function in R.
+        
+        def self.generate(formula, data, **options)
+            mapped = ""
+            if options.size > 0
+                mapped = options.map { |k, v| "#{k}=#{v}" }.join(", ")
+                mapped = ", " + mapped
+            end
+            
+            Rust.exclusive do
+                Rust["aov.data"] = data
+                Rust._eval("aov.model.result <- aov(#{formula.to_R}, data=aov.data#{mapped})")
+                result = ANOVAModel.new(Rust["aov.model.result"])
+                result.r_mirror_to("aov.model.result")
+                return result
+            end
+        end
+        
+        ##
+        # Creates a new +model+.
+        
+        def initialize(model)
+            @model = model
+        end
+        
+        ##
+        # Returns the model.
+        
+        def model
+            @model
+        end
+        
+        ##
+        # Returns a summary of the ANOVA model through the summary function in R.
+        
+        def summary
+            unless @summary
+                Rust.exclusive do
+                    Rust._eval("aov.smr <- summary(#{self.r_mirror})")
+                    @summary = Rust['aov.smr']
+                end
+            end
+            
+            return @summary
+        end
+    end
+end
+
+module Rust::RBindings
+    def aov(formula, data, **options)
+        return ANOVAModel.generate(formula, data, **options)
+    end
+end

data/lib/rust/models/regression.rb

@@ -0,0 +1,258 @@
+require_relative '../core'
+require_relative '../stats/descriptive'
+require_relative '../stats/correlation'
+
+module Rust::Models
+end
+
+##
+# Contains classes that allow to run regression models.
+
+module Rust::Models::Regression
+    
+    ##
+    # Generic regression model in R.
+    
+    class RegressionModel < Rust::RustDatatype
+        def self.can_pull?(type, klass)
+            # Can only pull specific sub-types
+            return false
+        end
+        
+        def load_in_r_as(variable_name)
+            @model.load_in_r_as(variable_name)
+        end
+
+        ##
+        # Generates a new regression model. +object_type+ is the Ruby class of the model object; +model_type+ represents 
+        # the type of model at hand; +dependent_variable+ and +independent_variables+ are directly used as part of the 
+        # model formula. +data+ represents the dataset to be used. +options+ can be specified and directly passed to the
+        # model.
+        
+        def self.generate(object_type, model_type, dependent_variable, independent_variables, data, **options)
+            mapped = ""
+            if options.size > 0
+                mapped = options.map { |k, v| "#{k}=#{v}" }.join(", ")
+                mapped = ", " + mapped
+            end
+            
+            formula = Rust::Formula.new(dependent_variable, independent_variables.join(" + "))
+            
+            Rust.exclusive do
+                Rust["#{model_type}.data"] = data
+                
+                Rust._eval("#{model_type}.model.result <- #{model_type}(#{formula.to_R}, data=#{model_type}.data#{mapped})")
+                result = Rust["#{model_type}.model.result"]
+                result.r_mirror_to("#{model_type}.model.result")
+                
+                return result
+            end
+        end
+        
+        ##
+        # Creates a new +model+.
+            
+        def initialize(model)
+            raise StandardError if model.is_a?(RegressionModel)
+            @model = model
+        end
+        
+        def model
+            @model
+        end
+        
+        ##
+        # Returns the residuals of the model.
+        
+        def residuals
+            Rust.exclusive do
+                @residuals = Rust["residuals(#{self.r_mirror})"] unless @residuals
+            end
+            
+            return @residuals
+        end
+        
+        ##
+        # Returns the fitted values of the model.
+        
+        def fitted
+            Rust.exclusive do
+                @fitted = Rust["fitted(#{self.r_mirror})"] unless @fitted
+            end
+            
+            return @fitted
+        end
+        
+        ##
+        # Returns the actual values in the dataset.
+        
+        def actuals            
+            return self.fitted.zip(self.residuals).map { |couple| couple.sum }
+        end
+        
+        ##
+        # Returns the r-squared of the model.
+        
+        def r_2
+            return self.summary|"r.squared"
+        end
+        
+        ##
+        # Returns the adjusted r-squared of the model.
+        
+        def r_2_adjusted
+            return self.summary|"adj.r.squared"
+        end
+        
+        ##
+        # Returns the mean squared error of the model.
+        
+        def mse
+            Rust::Descriptive.variance(self.residuals)
+        end
+        
+        ##
+        # Returns the coefficients of the model.
+        
+        def coefficients
+            a = self.summary|"coefficients"
+        end
+        
+        def method_missing(name, *args)
+            return model|name.to_s
+        end
+        
+        ##
+        # Returns a summary for the model using the summary function in R.
+        
+        def summary
+            unless @summary
+                Rust.exclusive do
+                    @summary = Rust["summary(#{self.r_mirror})"]
+                end
+            end
+            
+            return @summary
+        end
+        
+        def r_hash
+            @model.r_hash
+        end
+    end
+    
+    ##
+    # Represents a linear regression model in R.
+    
+    class LinearRegressionModel < RegressionModel
+        def self.can_pull?(type, klass)
+            return type == "list" && klass == "lm"
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            model = Rust::RustDatatype.pull_variable(variable, Rust::List)
+            
+            return LinearRegressionModel.new(model)
+        end
+        
+        ##
+        # Generates a linear regression model, given its +dependent_variable+ and +independent_variables+ and its +data+. 
+        # +options+ can be specified and directly passed to the model. 
+        
+        def self.generate(dependent_variable, independent_variables, data, **options)
+            RegressionModel.generate(
+                LinearRegressionModel,
+                "lm", 
+                dependent_variable, 
+                independent_variables, 
+                data, 
+                **options
+            )
+        end
+    end
+    
+    ##
+    # Represents a linear mixed effects model in R.
+    
+    class LinearMixedEffectsModel < RegressionModel
+        def self.can_pull?(type, klass)
+            return type == "S4" && klass == "lmerModLmerTest"
+        end
+        
+        def self.pull_priority
+            1
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            model = Rust::RustDatatype.pull_variable(variable, Rust::S4Class)
+            
+            return LinearMixedEffectsModel.new(model)
+        end
+        
+        def summary
+            unless @summary
+                Rust.exclusive do
+                    Rust._eval("tmp.summary <- summary(#{self.r_mirror})")
+                    Rust._eval("mode(tmp.summary$objClass) <- \"list\"")
+                    Rust._eval("tmp.summary$logLik <- attributes(tmp.summary$logLik)")
+                    @summary = Rust["tmp.summary"]
+                end
+            end
+            
+            return @summary
+        end
+        
+        ##
+        # Generates a linear mixed effects model, given its +dependent_variable+ and +independent_variables+ and its +data+. 
+        # +options+ can be specified and directly passed to the model. 
+        
+        def self.generate(dependent_variable, fixed_effects, random_effects, data, **options)
+            Rust.prerequisite("lmerTest")
+            Rust.prerequisite("rsq")
+            
+            random_effects = random_effects.map { |effect| "(1|#{effect})" }
+            
+            RegressionModel.generate(
+                LinearMixedEffectsModel,
+                "lmer", 
+                dependent_variable, 
+                fixed_effects + random_effects, 
+                data, 
+                **options
+            )
+        end
+        
+        def r_2
+            Rust.exclusive do
+                Rust._eval("tmp.rsq <- rsq(#{self.r_mirror}, adj=F)")
+                return Rust['tmp.rsq']
+            end
+        end
+        
+        def r_2_adjusted
+            Rust.exclusive do
+                Rust._eval("tmp.rsq <- rsq(#{self.r_mirror}, adj=T)")
+                return Rust['tmp.rsq']
+            end
+        end
+    end
+end
+
+module Rust::RBindings
+    def lm(formula, data, **options)
+        independent = formula.right_part.split("+").map { |v| v.strip }
+        return LinearRegressionModel.generate(formula.left_part, independent, data, **options)
+    end
+    
+    def lmer(formula, data, **options)
+        independent = formula.right_part.split("+").map { |v| v.strip }
+        
+        RegressionModel.generate(
+            LinearMixedEffectsModel,
+            "lmer", 
+            formula.left_part, 
+            independent, 
+            data,
+            **options
+        )
+    end
+end