rust 0.3 → 0.9

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

data/lib/{rust-plots.rb → rust/plots/core.rb}

@@ -1,11 +1,11 @@
-require_relative 'rust-core'
-require_relative 'rust-calls'
+require_relative '../core'
 
 module Rust::Plots
     class BasePlot
         def initialize
-            @plugins = []
+            @renderables = []
             @options = Rust::Options.new
+            @override_options = true
         end
         
         def x_label(label)
@@ -20,6 +20,14 @@ module Rust::Plots
             return self
         end
         
+        def palette(size)
+            if size <= 1
+                return ['black']
+            else
+                return Rust._pull("hcl.colors(n=#{size})")
+            end
+        end
+        
         def x_range(range)
             @options['xlim'] = range
             
@@ -36,7 +44,13 @@ module Rust::Plots
             @options['xaxt'] = 'n'
             @options['yaxt'] = 'n'
             
-            self.plug(axis)
+            self._add_renderable(axis)
+            
+            return self
+        end
+        
+        def grid(grid)
+            self._add_renderable(grid)
             
             return self
         end
@@ -53,21 +67,25 @@ module Rust::Plots
             return self
         end
         
-        def plug(plugin)
-            raise TypeError, "Expected Plugin" unless plugin.is_a?(Plugin)
-            @plugins << plugin
+        def _add_renderable(renderable)
+            raise TypeError, "Expected Renderable" unless renderable.is_a?(Renderable)
+            @renderables << renderable
             
             return self
         end
         
         def []=(option, value)
-            @options[option] = value
+            @options[option.to_s] = value
+        end
+        
+        def _do_not_override_options!
+            @override_options = false
         end
         
         def show()
             Rust.exclusive do
                 self._show
-                self._run_plugins
+                self._render_others
             end
             
             return self
@@ -82,7 +100,7 @@ module Rust::Plots
             Rust.exclusive do
                 pdf_function.call
                 self._show
-                self._run_plugins
+                self._render_others
                 Rust._eval("dev.off()")
             end
             
@@ -94,9 +112,9 @@ module Rust::Plots
             raise "You are trying to show a BasePlot"
         end
         
-        def _run_plugins()
-            @plugins.each do |plugin|
-                plugin._run()
+        def _render_others()
+            @renderables.each do |renderable|
+                renderable._render()
             end
             
             return self
@@ -106,7 +124,7 @@ module Rust::Plots
             result = @options.clone
             
             options.each do |key, value|
-                result[key] = value
+                result[key] = value if !result[key] || @override_options
             end
             
             result.select! { |k, v| v != nil }
@@ -115,113 +133,7 @@ module Rust::Plots
         end
     end
     
-    class ScatterPlot < BasePlot
-        def initialize(x, y)
-            super()
-            @x = x
-            @y = y
-        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()
-            Rust["plotter.x"] = @x
-            Rust["plotter.y"] = @y
-            
-            function = Rust::Function.new("plot")
-            function.options = self._augmented_options
-            function.arguments << Rust::Variable.new("plotter.x")
-            function.arguments << Rust::Variable.new("plotter.y")
-            
-            function.call
-            
-            return self
-        end
-    end
-    
-    class DistributionPlot < BasePlot
-        def initialize
-            super()
-            @series = []
-        end
-        
-        def series(data, **options)
-            @series << [data, options]
-            
-            return self
-        end
-    end
-    
-    class DensityPlot < DistributionPlot
-        protected
-        def _show()
-            first = true
-            @series.each do |data, options|
-                Rust["plotter.series"] = data
-                
-                if first
-                    first = false
-                    command = "plot"
-                else
-                    command = "lines"
-                end
-                
-                function = Rust::Function.new(command)
-                function.options = self._augmented_options({"col" => options[:color]})
-                function.arguments << Rust::Variable.new("density(plotter.series)")
-                function.call
-            end
-            
-            return self
-        end
-    end
-    
-    class BoxPlot < DistributionPlot
-        protected
-        def _show()
-            function = Rust::Function.new("boxplot")
-            
-            names = []
-            @series.each_with_index do |data, i|
-                series, options = *data
-                varname = "plotter.series#{i}"
-                Rust[varname] = series
-                function.arguments << Rust::Variable.new(varname)
-                names << (options[:name] || (i+1).to_s)
-            end
-            
-            function.options = self._augmented_options({'names' => names})
-            
-            function.call
-            
-            return self
-        end
-    end
-    
-    class Plugin
+    class Renderable
         def initialize
             @options = Rust::Options.new
         end
@@ -233,12 +145,12 @@ module Rust::Plots
         end
         
         protected
-        def _run()
-            raise "You are trying to run an abstract Plugin"
+        def _render()
+            raise "You are trying to run an abstract Renderable"
         end
     end
     
-    class Axis < Plugin
+    class Axis < Renderable
         BELOW = 1
         LEFT  = 2
         ABOVE = 3
@@ -276,7 +188,7 @@ module Rust::Plots
             return self
         end
         
-        def _run()
+        def _render()
             function = Rust::Function.new("axis")
             function.options = @options
             
@@ -286,7 +198,7 @@ module Rust::Plots
         end
     end
     
-    class Grid < Plugin
+    class Grid < Renderable
         def initialize
             super()
             
@@ -330,7 +242,7 @@ module Rust::Plots
             return self
         end
         
-        def _run()
+        def _render()
             function = Rust::Function.new("grid")
             
             function.arguments << @x
@@ -345,7 +257,30 @@ module Rust::Plots
 end
 
 module Rust::RBindings
-    def plot(x, y)
-        Rust::Plots::ScatterPlot.new(x, y).show
+    def plot(x, y=(1..x.size).to_a, **options)
+        result = Rust::Plots::ScatterPlot.new(x, y)
+        
+        options.each do |k, v|
+            result[k] = v
+        end
+        
+        result._do_not_override_options!
+        
+        result.show
+    end
+    
+    def boxplot(*args, **options)
+        result = Rust::Plots::BoxPlot.new
+        options.each do |k, v|
+            result[k] = v
+        end
+        
+        result._do_not_override_options!
+        
+        args.each do |s|
+            result.series(s)
+        end
+        
+        result.show
     end
 end