rust 0.4 → 0.10

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,143 @@
+require_relative 'core'
+
+module Rust::Plots
+    
+    ##
+    # Allows to create one or many scatter plots.
+    
+    class ScatterPlot < BasePlot
+        
+        ##
+        # Creates a new scatter plot, given two arrays of values +x+ and +y+ for the respective axes (optional).
+        # +options+ can be specified and directly passed to the plot function in R.
+        
+        def initialize(x = nil, y = nil, **options)
+            super()
+            @series = []
+            if x && y
+                self.series(x, y, **options)
+            end
+        end
+        
+        ##
+        # Adds a new data series, given the values for the +x+ and +y+ axes.
+        # +options+ can be specified and directly passed to the plot function in R.
+        
+        def series(x, y, **options)
+            @series << [x, y, options]
+            
+            return self
+        end
+        
+        ##
+        # Sets the thickness of the plot lines.
+        
+        def thickness(t)
+            self['lwd'] = t
+            
+            return self
+        end
+        
+        ##
+        # Changes the plot type to lines.
+        
+        def lines()
+            self['type'] = "l"
+            
+            return self
+        end
+        
+        ##
+        # Changes the plot type to points.
+        
+        def points()
+            self['type'] = "p"
+            
+            return self
+        end
+        
+        ##
+        # Changes the plot type to lines and points.
+        
+        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 a bar plot in R.
+    
+    class BarPlot < BasePlot
+        
+        ##
+        # Creates a new bar plot with the given +bars+ values.
+        
+        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,37 +1,75 @@
-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']
+            else
+                return Rust._pull("hcl.colors(n=#{size})")
+            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'
@@ -42,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
             
@@ -67,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
@@ -75,6 +125,9 @@ module Rust::Plots
             @override_options = false
         end
         
+        ##
+        # Shows the plot in a window.
+        
         def show()
             Rust.exclusive do
                 self._show
@@ -84,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)
@@ -126,117 +182,21 @@ 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
+    ##
+    # Represents any element that can be rendered in a plot (e.g., axes or grids).
     
     class Renderable
+        
+        ##
+        # Creates a new empty renderable object.
+        
         def initialize
             @options = Rust::Options.new
         end
         
+        ##
+        # Sets an option for the renderable object.
+        
         def []=(option, value)
             @options[option] = value
             
@@ -249,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()
             
@@ -297,7 +263,14 @@ module Rust::Plots
         end
     end
     
+    ##
+    # Represents a grid for a plot.
+    
     class Grid < Renderable
+        
+        ##
+        # Creates a new grid
+        
         def initialize
             super()
             
@@ -305,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 Rust:: Correlation
+##
+# 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