rust 0.7 → 0.11

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

@@ -1,26 +1,45 @@
-require_relative 'rust-core'
-require_relative 'rust-calls'
+require_relative '../core'
+
+##
+# Module that contains classes for plotting.
 
 module Rust::Plots
+    
+    ##
+    # Represents a generic plot in R.
+    
     class BasePlot
+        
+        ##
+        # Creates a new base plot object.
+        
         def initialize
             @renderables = []
             @options = Rust::Options.new
             @override_options = true
         end
         
+        ##
+        # Sets the x-axis label.
+        
         def x_label(label)
             @options['xlab'] = label
             
             return self
         end
         
+        ##
+        # Sets the y-axis label.
+        
         def y_label(label)
             @options['ylab'] = label
             
             return self
         end
         
+        ##
+        # Returns a color palette of the given +size+.
+        
         def palette(size)
             if size <= 1
                 return ['black']
@@ -29,17 +48,28 @@ module Rust::Plots
             end
         end
         
+        ##
+        # Sets the limits for the x-axis.
+        
         def x_range(range)
             @options['xlim'] = range
             
             return self
         end
+        alias :xlim :x_range
+        
+        ##
+        # Sets the limits for the y-axis.
         
         def y_range(range)
             @options['ylim'] = range
             
             return self
         end
+        alias :ylim :y_range
+        
+        ##
+        # Adds an +axis+ to show instead of the default ones.
         
         def axis(axis)
             @options['xaxt'] = 'n'
@@ -50,18 +80,27 @@ module Rust::Plots
             return self
         end
         
+        ##
+        # Shows the given +grid+.
+        
         def grid(grid)
             self._add_renderable(grid)
             
             return self
         end
         
+        ##
+        # Sets the +title+ of the plot.
+        
         def title(title)
             @options['main'] = title
             
             return self
         end
         
+        ##
+        # Sets the +color+ of the plot.
+        
         def color(color)
             @options['col'] = color
             
@@ -75,6 +114,9 @@ module Rust::Plots
             return self
         end
         
+        ##
+        # Sets any R +option+ with the given +value+.
+        
         def []=(option, value)
             @options[option.to_s] = value
         end
@@ -83,6 +125,9 @@ module Rust::Plots
             @override_options = false
         end
         
+        ##
+        # Shows the plot in a window.
+        
         def show()
             Rust.exclusive do
                 self._show
@@ -92,6 +137,9 @@ module Rust::Plots
             return self
         end
         
+        ##
+        # Prints the plot on a PDF file at path. +options+ can be specified for the PDF (e.g., width and height).
+        
         def pdf(path, **options)
             pdf_function = Rust::Function.new("pdf")
             pdf_function.options = Rust::Options.from_hash(options)
@@ -134,178 +182,21 @@ module Rust::Plots
         end
     end
     
-    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
+    ##
+    # Represents any element that can be rendered in a plot (e.g., axes or grids).
     
-    class BarPlot < BasePlot
-        def initialize(bars)
-            super()
-            @bars = bars
-        end
+    class Renderable
         
-        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
-    
-    class DistributionPlot < BasePlot
-        def initialize
-            super()
-            @series = []
-        end
+        ##
+        # Creates a new empty renderable object.
         
-        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 Renderable
         def initialize
             @options = Rust::Options.new
         end
         
+        ##
+        # Sets an option for the renderable object.
+        
         def []=(option, value)
             @options[option] = value
             
@@ -318,12 +209,18 @@ module Rust::Plots
         end
     end
     
+    ##
+    # Represents an axis for a plot.
+    
     class Axis < Renderable
         BELOW = 1
         LEFT  = 2
         ABOVE = 3
         RIGHT = 4
         
+        ##
+        # Creates a new axis at the given +side+ (constants BELOW, LEFT, ABOVE, and RIGHT are available).
+        
         def initialize(side)
             super()
             
@@ -366,7 +263,14 @@ module Rust::Plots
         end
     end
     
+    ##
+    # Represents a grid for a plot.
+    
     class Grid < Renderable
+        
+        ##
+        # Creates a new grid
+        
         def initialize
             super()
             
@@ -374,36 +278,54 @@ module Rust::Plots
             @y = Float::NAN
         end
         
+        ##
+        # Sets the x intervals.
+        
         def x(value)
             @x = value
             
             return self
         end
         
+        ##
+        # Sets the y intervals.
+        
         def y(value)
             @y = value
             
             return self
         end
         
+        ##
+        # Automatically sets the x intervals.
+        
         def auto_x
             @x = nil
             
             return self
         end
         
+        ##
+        # Automatically sets the y intervals.
+        
         def auto_y
             @y = nil
             
             return self
         end
         
+        ##
+        # Hides x axis lines.
+        
         def hide_x
             @x = Float::NAN
             
             return self
         end
         
+        ##
+        # Hides y axis lines.
+        
         def hide_y
             @y = Float::NAN
             

data/lib/rust/plots/distribution-plots.rb

@@ -0,0 +1,75 @@
+require_relative 'core'
+
+module Rust::Plots
+    
+    ##
+    # Represents any distribution-related plot (e.g., boxplots).
+    
+    class DistributionPlot < BasePlot
+        def initialize
+            super()
+            @series = []
+        end
+        
+        ##
+        # Adds a series of data points. +options+ can be specified and directly passed to the R plotting function.
+        
+        def series(data, **options)
+            @series << [data, options]
+            
+            return self
+        end
+    end
+    
+    ##
+    # Represents a density plot in R.
+    
+    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
+    
+    ##
+    # Represents a boxplot in R.
+    
+    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
+end

data/lib/rust/stats/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-basics.rb → rust/stats/correlation.rb}

@@ -1,7 +1,18 @@
-require_relative 'rust-core'
+require_relative '../core'
+
+##
+# Module containing all the correlation-related statistics.
 
 module Rust::Correlation
+    
+    ##
+    # Pearson correlation utility methods.
+    
     class Pearson
+        
+        ##
+        # Runs the Pearson correlation test between +d1+ and +d2+.
+        
         def self.test(d1, d2)
             raise TypeError, "Expecting Array of numerics" if !d1.is_a?(Array) || !d1.all? { |e| e.is_a?(Numeric) }
             raise TypeError, "Expecting Array of numerics" if !d2.is_a?(Array) || !d2.all? { |e| e.is_a?(Numeric) }
@@ -23,12 +34,22 @@ module Rust::Correlation
             end
         end
         
+        ##
+        # Returns the Pearson correlation index between +d1+ and +d2+
+        
         def self.estimate(d1, d2)
             self.test(d1, d2).correlation
         end
     end
     
+    ##
+    # Spearman correlation utility methods.
+    
     class Spearman
+        
+        ##
+        # Runs the Spearman correlation test between +d1+ and +d2+.
+        
         def self.test(d1, d2)
             raise TypeError, "Expecting Array of numerics" if !d1.is_a?(Array) || !d1.all? { |e| e.is_a?(Numeric) }
             raise TypeError, "Expecting Array of numerics" if !d2.is_a?(Array) || !d2.all? { |e| e.is_a?(Numeric) }
@@ -50,12 +71,22 @@ module Rust::Correlation
             end
         end
         
+        ##
+        # Returns the Spearman correlation index between +d1+ and +d2+
+        
         def self.estimate(d1, d2)
             self.test(d1, d2).correlation
         end
     end
     
+    ##
+    # Kendall correlation utility methods.
+    
     class Kendall
+        
+        ##
+        # Runs the Kendall correlation test between +d1+ and +d2+.
+        
         def self.test(d1, d2)
             raise TypeError, "Expecting Array of numerics" if !d1.is_a?(Array) || !d1.all? { |e| e.is_a?(Numeric) }
             raise TypeError, "Expecting Array of numerics" if !d2.is_a?(Array) || !d2.all? { |e| e.is_a?(Numeric) }
@@ -64,7 +95,7 @@ module Rust::Correlation
                 Rust['correlation.a'] = d1
                 Rust['correlation.b'] = d2
                 
-                _, warnings = Rust._eval("correlation.result <- cor.test(correlation.a, correlation.b, method='p')", true)
+                _, warnings = Rust._eval("correlation.result <- cor.test(correlation.a, correlation.b, method='k')", true)
                 
                 result = Result.new
                 result.name             = "Kendall's rank correlation tau"
@@ -77,11 +108,17 @@ module Rust::Correlation
             end
         end
         
+        ##
+        # Returns the Kendall correlation index between +d1+ and +d2+
+        
         def self.estimate(d1, d2)
             self.test(d1, d2).correlation
         end
     end
     
+    ##
+    # Result of a correlation test.
+    
     class Result
         attr_accessor   :name
         attr_accessor   :statistics
@@ -96,10 +133,16 @@ module Rust::Correlation
             @exact = true
         end
         
+        ##
+        # Returns the statistic with the specified +name+.
+        
         def [](name)
             return @statistics[name.to_sym]
         end
         
+        ##
+        # Sets the +value+ for the the statistic with the specified +name+.
+        
         def []=(name, value)
             @statistics[name.to_sym] = value
         end

data/lib/{rust-descriptive.rb → rust/stats/descriptive.rb}

@@ -1,15 +1,23 @@
-require 'code-assertions'
+require_relative '../core'
 
-require_relative 'rust-core'
+##
+# Module containing utilities for descriptive statistics.
 
 module Rust::Descriptive
     class << self
+        
+        ##
+        # Computes the arithmetic mean of the given +data+.
+        
         def mean(data)
             raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
             
             return data.sum.to_f / data.size
         end
         
+        ##
+        # Computes the standard deviation of the given +data+.
+        
         def standard_deviation(data)
             raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
             
@@ -18,6 +26,9 @@ module Rust::Descriptive
         alias :sd     :standard_deviation
         alias :stddev :standard_deviation
         
+        ##
+        # Computes the variance of the given +data+.
+        
         def variance(data)
             raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
             return Float::NAN if data.size < 2
@@ -27,6 +38,9 @@ module Rust::Descriptive
         end
         alias :var     :variance
         
+        ##
+        # Computes the median of the given +data+.
+        
         def median(data)
             raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
             
@@ -41,13 +55,19 @@ module Rust::Descriptive
             end
         end
         
+        ##
+        # Sums the given +data+.
+        
         def sum(data)
             raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
             
             return data.sum
         end
         
-        def quantile(data, percentiles=[0.0, 0.25, 0.5, 0.75, 1.0])
+        ##
+        # Returns the quantiles of the given +data+, given the +percentiles+ (optional).
+        
+        def quantile(data, percentiles = [0.0, 0.25, 0.5, 0.75, 1.0])
             raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
             raise TypeError, "Expecting Array of numerics" if !percentiles.is_a?(Array) || !percentiles.all? { |e| e.is_a?(Numeric) }
             raise "Percentiles outside the range: #{percentiles}" if percentiles.any? { |e| !e.between?(0, 1) }
@@ -79,10 +99,17 @@ module Rust::Descriptive
             return percentiles.zip(result).to_h
         end
         
+        ##
+        # Returns the outliers in +data+ using Tukey's fences, with a given +k+.
+        
         def outliers(data, k=1.5, **opts)
             outliers_according_to(data, data, k, **opts)
         end
         
+        ##
+        # Returns the outliers in +data+ using Tukey's fences, with a given +k+, with respect to different data
+        # distribution (+data_distribution+).
+        
         def outliers_according_to(data, data_distribution, k=1.5, **opts)
             quantiles = Rust::Descriptive.quantile(data_distribution, [0.25, 0.75])
             q1 = quantiles[0.25]
@@ -106,3 +133,25 @@ module Rust::Descriptive
         end
     end
 end
+
+module Rust::RBindings
+    def mean(series)
+        Rust::Descriptive.mean(series)
+    end
+    
+    def median(series)
+        Rust::Descriptive.median(series)
+    end
+    
+    def var(series)
+        Rust::Descriptive.variance(series)
+    end
+    
+    def sd(series)
+        Rust::Descriptive.standard_deviation(series)
+    end
+    
+    def quantile(series, percentiles = [0.0, 0.25, 0.5, 0.75, 1.0])
+        Rust::Descriptive.quantile(series, percentiles)
+    end
+end