rust 0.7 → 0.9

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

data/lib/rust/models/anova.rb

@@ -0,0 +1,60 @@
+require_relative '../core'
+
+module Rust
+    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
+        
+        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
+        
+        def initialize(model)
+            @model = model
+        end
+        
+        def model
+            @model
+        end
+        
+        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,205 @@
+require_relative '../core'
+require_relative '../stats/descriptive'
+require_relative '../stats/correlation'
+
+module Rust::Models
+end
+
+module Rust::Models::Regression
+    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
+
+        
+        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
+            
+        def initialize(model)
+            raise StandardError if model.is_a?(RegressionModel)
+            @model = model
+        end
+        
+        def model
+            @model
+        end
+        
+        def residuals
+            Rust.exclusive do
+                @residuals = Rust["residuals(#{self.r_mirror})"] unless @residuals
+            end
+            
+            return @residuals
+        end
+        
+        def fitted
+            Rust.exclusive do
+                @fitted = Rust["fitted(#{self.r_mirror})"] unless @fitted
+            end
+            
+            return @fitted
+        end
+        
+        def actuals            
+            return self.fitted.zip(self.residuals).map { |couple| couple.sum }
+        end
+        
+        def r_2
+            return self.summary|"r.squared"
+        end
+        
+        def r_2_adjusted
+            return self.summary|"adj.r.squared"
+        end
+        
+        def mse
+            Rust::Descriptive.variance(self.residuals)
+        end
+        
+        def coefficients
+            a = self.summary|"coefficients"
+        end
+        
+        def method_missing(name, *args)
+            return model|name.to_s
+        end
+        
+        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
+    
+    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
+        
+        def self.generate(dependent_variable, independent_variables, data, **options)
+            RegressionModel.generate(
+                LinearRegressionModel,
+                "lm", 
+                dependent_variable, 
+                independent_variables, 
+                data, 
+                **options
+            )
+        end
+    end
+    
+    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
+        
+        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

data/lib/rust/plots/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/plots/basic-plots.rb

@@ -0,0 +1,111 @@
+require_relative 'core'
+
+module Rust::Plots
+    class ScatterPlot < BasePlot
+        def initialize(x = nil, y = nil, **options)
+            super()
+            @series = []
+            if x && y
+                self.series(x, y, **options)
+            end
+        end
+        
+        def series(x, y, **options)
+            @series << [x, y, options]
+            
+            return self
+        end
+        
+        def thickness(t)
+            self['lwd'] = t
+            
+            return self
+        end
+        
+        def lines()
+            self['type'] = "l"
+            
+            return self
+        end
+        
+        def points()
+            self['type'] = "p"
+            
+            return self
+        end
+        
+        def lines_and_points()
+            self['type'] = "b"
+            
+            return self
+        end
+        
+        protected
+        def _show()
+            first = true
+            palette = self.palette(@series.size)
+            i = 0
+            
+            base_options = {}
+            unless @options['xlim']
+                x_values = @series.map { |v| v[0] }.flatten
+                y_values = @series.map { |v| v[1] }.flatten
+                
+                base_options[:xlim] = [x_values.min, x_values.max]
+                base_options[:ylim] = [y_values.min, y_values.max]
+            end
+            
+            @series.each do |x, y, options|
+                options = options.merge(base_options)
+                Rust["plotter.x"] = x
+                Rust["plotter.y"] = y
+                
+                function = nil
+                if first
+                    function = Rust::Function.new("plot")
+                    first = false
+                else
+                    function = Rust::Function.new("lines")
+                end
+                
+                augmented_options = {}
+                augmented_options['col'] = options[:color] || palette[i]
+                augmented_options['xlim'] = options[:xlim] if options[:xlim]
+                augmented_options['ylim'] = options[:ylim] if options[:ylim]
+                
+                function.options = self._augmented_options(augmented_options)
+                function.arguments << Rust::Variable.new("plotter.x")
+                function.arguments << Rust::Variable.new("plotter.y")
+                
+                function.call
+                
+                i += 1
+            end
+            
+            return self
+        end
+    end
+    
+    class BarPlot < BasePlot
+        def initialize(bars)
+            super()
+            @bars = bars
+        end
+        
+        protected
+        def _show()
+            Rust["plotter.bars"] = @bars.values
+            Rust["plotter.labels"] = @bars.keys
+            
+            Rust._eval("names(plotter.bars) <- plotter.labels")
+            
+            function = Rust::Function.new("barplot")
+            function.options = self._augmented_options
+            function.arguments << Rust::Variable.new("plotter.bars")
+            
+            function.call
+            
+            return self
+        end
+    end
+end