rust 0.9 → 0.12

data/lib/rust/external/ggplot2/themes.rb

@@ -0,0 +1,435 @@
+require 'json'
+require_relative 'core'
+
+module Rust::Plots::GGPlot
+    class Theme < Layer
+        def self.from_h(options)            
+            starting = options.delete('_starting')
+            options = options.map do |key, value|
+                if value.is_a?(Hash)
+                    case value.delete('_type').split("::").last
+                    when 'TextElement'
+                        [key, TextElement.new(**value)]
+                    when 'RectElement'
+                        [key, RectElement.new(**value)]
+                    when 'TextElement'
+                        [key, TextElement.new(**value)]
+                    when 'LineElement'
+                        [key, LineElement.new(**value)]
+                    end
+                else
+                    [key, value]
+                end
+            end.to_h
+            
+            return Theme.new(starting, **options)
+        end
+        
+        def self.load(filename)
+            json = JSON.parse(File.read(filename))
+            return self.from_h(json.to_h)
+        end
+        
+        def initialize(starting, **options)
+            super("theme", **options)
+            if starting
+                @starting = "theme_" + starting
+            end
+        end
+        
+        def to_R
+            result = super do |options, arguments| 
+                [
+                    options.map { |k, v| [k.to_s.gsub("_", "."), v] }.to_h,
+                    arguments
+                ] 
+            end
+            
+            result = Rust::Function.new(@starting).to_R + " + " +  result if @starting
+            
+            return result
+        end
+        
+        def to_h
+            options = @options.clone
+            
+            options['_starting'] = @starting.sub("theme_", "")
+            options = options.map do |key, value|
+                [key, value.is_a?(Theme::Element) ? value.to_h : value]
+            end.to_h
+            
+            return options
+        end
+        
+        def save(path, force = false)
+            if !force && FileTest.exist?(path)
+                raise "File already existing."
+            end
+            
+            File.open(path, "w") do |f|
+                f.write(
+                    JSON.pretty_generate(
+                        self.to_h
+                    )
+                )
+            end
+            
+            return true
+        end
+    end
+    
+    class Theme::Element
+        attr_reader :options
+        
+        def initialize(**options)
+            @options = options
+        end
+        
+        def r_function
+            raise "Not implemented for generic theme element"
+        end
+        
+        def to_R
+            options = @options.map { |k, v| [k.to_s.gsub("_", "."), v] }.to_h
+            
+            function = Rust::Function.new(self.r_function)
+            function.options = Rust::Options.from_hash(options)
+            
+            return function.to_R
+        end
+        
+        def to_h
+            hash = @options.clone
+            hash['_type'] = self.class.name
+            return hash
+        end
+    end
+    
+    class Theme::TextElement < Theme::Element
+        def r_function
+            return "element_text"
+        end
+    end
+    
+    class Theme::LineElement < Theme::Element
+        def r_function
+            return "element_line"
+        end
+    end
+    
+    class Theme::RectElement < Theme::Element
+        def r_function
+            return "element_rect"
+        end
+    end
+    
+    class Theme::BlankElement < Theme::Element
+        def r_function
+            return "element_blank"
+        end
+    end
+    
+    class ThemeComponentBuilder
+        def initialize(namespace=nil)
+            @namespace = namespace
+            @options = {}
+        end
+        
+        def option(key, value)
+            key = "#@namespace.#{key}" if @namespace
+            @options[key] = value
+            
+            return self
+        end
+        
+        def [](key)
+            key = "#@namespace.#{key}" if @namespace
+            return @options[key]
+        end
+        
+        def line_el(value)
+            if value.is_a?(Theme::LineElement) || value.is_a?(Theme::BlankElement)
+                return value
+            elsif value.is_a?(Hash)
+                return Theme::LineElement.new(**value)
+            else
+                raise "Expected line or hash"
+            end
+        end
+        
+        def rect_el(value)
+            if value.is_a?(Theme::RectElement) || value.is_a?(Theme::BlankElement)
+                return value
+            elsif value.is_a?(Hash)
+                return Theme::RectElement.new(**value)
+            else
+                raise "Expected rect or hash"
+            end
+        end
+        
+        def text_el(value)
+            if value.is_a?(Theme::TextElement) || value.is_a?(Theme::BlankElement)
+                return value
+            elsif value.is_a?(Hash)
+                return Theme::TextElement.new(**value)
+            else
+                raise "Expected text or hash"
+            end
+        end
+        
+        def unit_el(value)
+            numeric = nil
+            unit = nil
+            
+            if input.is_a?(String)
+                numeric, unit = *input.scan(/^([0-9.]+)([A-Za-z]+)/).flatten
+                
+                raise "Unclear numeric part in #{input}" unless numeric
+                raise "Unclear unit part in #{input}"    unless unit
+            elsif input.is_a?(Numeric)
+                numeric = input
+                unit = "npc"
+            end
+            
+            raise "Unable to handle #{input}" unless numeric && unit
+            
+            function = Rust::Function.new("units")
+            function.arguments = Rust::Arguments.new([numeric, unit])
+            
+            return function.to_R
+        end
+        
+        def alignment_el(value)
+            if value.is_a?(String) || value.is_a?(Symbol)
+                case value.to_s.downcase
+                when 'left'
+                    value = 1
+                when 'right'
+                    value = 0
+                else
+                    value = 1
+                end
+            end
+            
+            return value
+        end
+        
+        def numeric_el(value)
+            raise "Expected number" unless value.is_a?(Numeric)
+            return value
+        end
+        
+        def build
+            @options
+        end
+    end
+    
+    class ThemeBuilder < ThemeComponentBuilder
+        def initialize(starting = 'bw')
+            super("plot")
+            @starting = starting
+        end
+        
+        def background(value)
+            self.option('background', rect_el(value))
+        end
+        
+        def title(value)
+            self.option('title', text_el(value))
+        end
+        
+        def axis
+            builder = ThemeAxisBuilder.new
+            yield builder
+            
+            @options.merge!(builder.build)
+            return self
+        end
+        
+        def legend
+            builder = ThemeLegendBuilder.new
+            yield builder
+            
+            @options.merge!(builder.build)
+            return self
+        end
+        
+        def panel
+            builder = ThemePanelBuilder.new
+            yield builder
+            
+            @options.merge!(builder.build)
+            return self
+        end
+        
+        def build
+            return Theme.new(@starting, **@options)
+        end
+    end
+    
+    class ThemeAxisBuilder < ThemeComponentBuilder
+        def initialize
+            super("axis")
+        end
+        
+        def line(value)
+            self.option('line', line_el(value))
+        end
+        
+        def text(value)
+            self.option('text', text_el(value))
+        end
+        
+        def text_x(value)
+            self.option('text.x', text_el(value))
+        end
+        
+        def text_y(value)
+            self.option('text.y', text_el(value))
+        end
+        
+        def title(value)
+            self.option('title', text_el(value))
+        end
+        
+        def title_x(value)
+            self.option('title.x', text_el(value))
+        end
+        
+        def title_y(value)
+            self.option('title.y', text_el(value))
+        end
+        
+        def ticks(value)
+            self.option('ticks', line_el(value))
+        end
+        
+        def ticks_length(value)
+            self.option('ticks.length', unit_el(value))
+        end
+    end
+    
+    class ThemeLegendBuilder < ThemeComponentBuilder
+        def initialize
+            super("legend")
+        end
+        
+        def position(value)
+            self.option('position', value)
+        end
+        
+        def justification(value)
+            self.option('justification', value)
+        end
+        
+        def background(value)
+            self.option('background', rect_el(value))
+        end
+        
+        def key_background(value)
+            self.option('key', rect_el(value))
+        end
+        
+        def key_size(value)
+            self.option('key.size', unit_el(value))
+        end
+        
+        def key_height(value)
+            self.option('key.height', unit_el(value))
+        end
+        
+        def key_width(value)
+            self.option('key.width', unit_el(value))
+        end
+        
+        def margin(value)
+            self.option('margin', unit_el(value))
+        end
+        
+        def text(value)
+            self.option('text', text_el(value))
+        end
+        
+        def text_align(value)
+            self.option('text.align', alignment_el(value))
+        end
+        
+        def title(value)
+            self.option('title', text_el(value))
+        end
+        
+        def title_align(value)
+            self.option('key.size', alignment_el(value))
+        end
+    end
+    
+    class ThemePanelBuilder < ThemeComponentBuilder
+        def initialize
+            super("panel")
+        end
+        
+        def background(value)
+            self.option('background', rect_el(value))
+        end
+        
+        def border(value)
+            self.option('border', rect_el(value))
+        end
+        
+        def grid_major(value)
+            self.option('grid.major', line_el(value))
+        end
+        
+        def grid_major_x(value)
+            self.option('grid.major.x', line_el(value))
+        end
+        
+        def grid_major_y(value)
+            self.option('grid.major.y', line_el(value))
+        end
+        
+        def grid_minor(value)
+            self.option('grid.minor', line_el(value))
+        end
+        
+        def grid_minor_x(value)
+            self.option('grid.minor.x', line_el(value))
+        end
+        
+        def grid_minor_y(value)
+            self.option('grid.minor.y', line_el(value))
+        end
+        
+        def aspect_ratio(value)
+            self.option('aspect.ratio', numeric_el(value))
+        end
+        
+        def margin(value)
+            self.option('margin', unit_el(value))
+        end
+        
+        def margin_x(value)
+            self.option('margin.x', unit_el(value))
+        end
+        
+        def margin_y(value)
+            self.option('margin.y', unit_el(value))
+        end
+    end
+    
+    self.default_theme = ThemeBuilder.new.
+            title(face: 'bold', size: 12).
+            legend do |legend|
+                legend.background(fill: 'white', size: 4, colour: 'white')
+                legend.position([0, 1])
+                legend.justification([0, 1])
+            end.
+            axis do |axis| 
+                axis.ticks(colour: 'grey70', size: 0.2)
+            end.
+            panel do |panel|
+                panel.grid_major(colour: 'grey70', size: 0.2)
+                panel.grid_minor(Theme::BlankElement.new)
+            end.
+            build
+end

data/lib/rust/external/ggplot2.rb

@@ -0,0 +1,5 @@
+require_relative 'ggplot2/core'
+require_relative 'ggplot2/geoms'
+require_relative 'ggplot2/themes'
+require_relative 'ggplot2/plot_builder'
+require_relative 'ggplot2/helper'

data/lib/rust/external/robustbase.rb

@@ -0,0 +1,44 @@
+require 'rust'
+
+Rust.prerequisite('robustbase')
+
+module Rust::Plots
+    class AdjustedBoxplot < DistributionPlot
+        protected
+        def _show()
+            function = Rust::Function.new("adjbox")
+            
+            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
+end
+
+module Rust::RBindings
+    def adjbox(*args, **options)
+        result = Rust::Plots::AdjustedBoxplot.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

data/lib/rust/models/anova.rb

@@ -1,6 +1,10 @@
 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")
@@ -16,6 +20,10 @@ module Rust
             @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
@@ -32,14 +40,23 @@ module Rust
             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

data/lib/rust/models/regression.rb

@@ -5,7 +5,14 @@ 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
@@ -16,6 +23,11 @@ module Rust::Models::Regression
             @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 = ""
@@ -36,6 +48,9 @@ module Rust::Models::Regression
                 return result
             end
         end
+        
+        ##
+        # Creates a new +model+.
             
         def initialize(model)
             raise StandardError if model.is_a?(RegressionModel)
@@ -46,6 +61,9 @@ module Rust::Models::Regression
             @model
         end
         
+        ##
+        # Returns the residuals of the model.
+        
         def residuals
             Rust.exclusive do
                 @residuals = Rust["residuals(#{self.r_mirror})"] unless @residuals
@@ -54,6 +72,9 @@ module Rust::Models::Regression
             return @residuals
         end
         
+        ##
+        # Returns the fitted values of the model.
+        
         def fitted
             Rust.exclusive do
                 @fitted = Rust["fitted(#{self.r_mirror})"] unless @fitted
@@ -62,22 +83,37 @@ module Rust::Models::Regression
             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
@@ -86,6 +122,9 @@ module Rust::Models::Regression
             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
@@ -101,6 +140,9 @@ module Rust::Models::Regression
         end
     end
     
+    ##
+    # Represents a linear regression model in R.
+    
     class LinearRegressionModel < RegressionModel
         def self.can_pull?(type, klass)
             return type == "list" && klass == "lm"
@@ -112,6 +154,10 @@ module Rust::Models::Regression
             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,
@@ -124,6 +170,9 @@ module Rust::Models::Regression
         end
     end
     
+    ##
+    # Represents a linear mixed effects model in R.
+    
     class LinearMixedEffectsModel < RegressionModel
         def self.can_pull?(type, klass)
             return type == "S4" && klass == "lmerModLmerTest"
@@ -152,6 +201,10 @@ module Rust::Models::Regression
             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")
@@ -169,7 +222,7 @@ module Rust::Models::Regression
         end
         
         def r_2
-        Rust.exclusive do
+            Rust.exclusive do
                 Rust._eval("tmp.rsq <- rsq(#{self.r_mirror}, adj=F)")
                 return Rust['tmp.rsq']
             end