rust 0.2 → 0.3

data/lib/rust-csv.rb

@@ -0,0 +1,95 @@
+require_relative 'rust-core'
+
+module Rust
+    class CSV
+        def self.read_all(pattern, **options)
+            result = {}
+            Dir.glob(pattern).each do |filename|
+                result[filename] = CSV.read(filename, **options)
+            end
+            return result
+        end
+        
+        def self.read(filename, **options)
+            hash = {}
+            labels = nil
+            
+            infer_numbers       = options.has_key?(:infer_numbers) ? options.delete(:infer_numbers) : true
+            infer_integers      = options.delete(:infer_integers)
+            
+            ::CSV.foreach(filename, **options) do |row|
+                # TODO fix this ugly patch
+                unless options[:headers]
+                    options[:headers] = (1..row.size).to_a.map { |e| "X#{e}" }
+                    
+                    return CSV.read(filename, **options)
+                end
+                
+                unless labels
+                    labels = row.headers
+                    labels.each do |label|
+                        hash[label] = []
+                    end
+                end
+                
+                labels.each do |label|
+                    hash[label] << row[label]
+                end
+            end
+            
+            result = Rust::DataFrame.new(hash)
+            if infer_numbers
+                result = self.auto_infer_types(result, infer_integers)
+            end
+            
+            return result
+        end
+        
+        def self.write(filename, dataframe, **options)
+            raise TypeError, "Expected Rust::DataFrame" unless dataframe.is_a?(Rust::DataFrame)
+            
+            write_headers = options[:headers] != false
+            options[:headers] = dataframe.column_names if options[:headers] == nil
+            
+            hash = {}
+            labels = nil
+            ::CSV.open(filename, 'w', write_headers: write_headers, **options) do |csv|
+                dataframe.each do |row|
+                    csv << row
+                end
+            end
+            
+            return true
+        end
+        
+        private
+        def self.auto_infer_types(dataframe, auto_infer_integers)
+            integer_columns = []
+            float_columns   = []
+            dataframe.column_names.each do |column_name|
+                values = dataframe.column(column_name)
+                
+                if values.all? { |s| !!Integer(s) rescue false }
+                    integer_columns << column_name
+                elsif values.all? { |s| !!Float(s) rescue false }
+                    float_columns << column_name
+                end
+            end
+            
+            unless auto_infer_integers
+                float_columns += integer_columns
+                integer_columns = []
+            end
+            
+            integer_columns.each do |numeric_column|
+                dataframe.transform_column!(numeric_column) { |v| v.to_i }
+            end
+            
+            float_columns.each do |numeric_column|
+                dataframe.transform_column!(numeric_column) { |v| v.to_f }
+            end
+            
+            return dataframe
+        end
+    end
+end

data/lib/rust-descriptive.rb

@@ -45,10 +45,10 @@ module Rust::Descriptive
             raise "Percentiles outside the range: #{percentiles}" if percentiles.any? { |e| !e.between?(0, 1) } 
             
             Rust.exclusive do 
-                Rust::R_ENGINE.data  = data
-                Rust::R_ENGINE.percs = percentiles
+                Rust['descriptive.data'] = data
+                Rust['descriptive.percs'] = percentiles
                 
-                call_result = Rust._pull("quantile(data, percs)")
+                call_result = Rust._pull("quantile(descriptive.data, descriptive.percs)")
                 assert { call_result.is_a?(Array) }
                 assert { call_result.size == percentiles.size }
                 

data/lib/rust-effsize.rb

@@ -25,17 +25,17 @@ module Rust::EffectSize::CliffDelta
             raise TypeError, "Expecting Array of numerics" if !d2.is_a?(Array) || !d2.all? { |e| e.is_a?(Numeric) }
             
             Rust.exclusive do
-                Rust::R_ENGINE.a = d1
-                Rust::R_ENGINE.b = d2
+                Rust['effsize.a'] = d1
+                Rust['effsize.b'] = d2
                 
-                Rust._eval("result = cliff.delta(a, b)")
+                Rust._eval("effsize.result = cliff.delta(effsize.a, effsize.b)")
                 
                 result = Rust::EffectSize::Result.new
                 result.name                 = "Cliff's delta"
-                result.estimate             = Rust._pull("result$estimate")
-                result.confidence_interval  = Range.new(*Rust._pull("result$conf.int"))
-                result.confidence_level     = Rust._pull("result$conf.level")
-                result.magnitude            = Rust._pull("as.character(result$magnitude)").to_sym
+                result.estimate             = Rust._pull("effsize.result$estimate")
+                result.confidence_interval  = Range.new(*Rust._pull("effsize.result$conf.int"))
+                result.confidence_level     = Rust._pull("effsize.result$conf.level")
+                result.magnitude            = Rust._pull("as.character(effsize.result$magnitude)").to_sym
                 
                 return result
             end
@@ -50,17 +50,17 @@ module Rust::EffectSize::CohenD
             raise TypeError, "Expecting Array of numerics" if !d2.is_a?(Array) || !d2.all? { |e| e.is_a?(Numeric) }
             
             Rust.exclusive do
-                Rust::R_ENGINE.a = d1
-                Rust::R_ENGINE.b = d2
+                Rust['effsize.a'] = d1
+                Rust['effsize.b'] = d2
                 
-                Rust._eval("result = cohen.d(a, b)")
+                Rust._eval("effsize.result = cohen.d(effsize.a, effsize.b)")
                 
                 result = Rust::EffectSize::Result.new
                 result.name                 = "Cohen's d"
-                result.estimate             = Rust._pull("result$estimate")
-                result.confidence_interval  = Range.new(*Rust._pull("result$conf.int"))
-                result.confidence_level     = Rust._pull("result$conf.level")
-                result.magnitude            = Rust._pull("as.character(result$magnitude)").to_sym
+                result.estimate             = Rust._pull("effsize.result$estimate")
+                result.confidence_interval  = Range.new(*Rust._pull("effsize.result$conf.int"))
+                result.confidence_level     = Rust._pull("effsize.result$conf.level")
+                result.magnitude            = Rust._pull("as.character(effsize.result$magnitude)").to_sym
                 
                 return result
             end

data/lib/rust-plots.rb

@@ -0,0 +1,351 @@
+require_relative 'rust-core'
+require_relative 'rust-calls'
+
+module Rust::Plots
+    class BasePlot
+        def initialize
+            @plugins = []
+            @options = Rust::Options.new
+        end
+        
+        def x_label(label)
+            @options['xlab'] = label
+            
+            return self
+        end
+        
+        def y_label(label)
+            @options['ylab'] = label
+            
+            return self
+        end
+        
+        def x_range(range)
+            @options['xlim'] = range
+            
+            return self
+        end
+        
+        def y_range(range)
+            @options['ylim'] = range
+            
+            return self
+        end
+        
+        def axis(axis)
+            @options['xaxt'] = 'n'
+            @options['yaxt'] = 'n'
+            
+            self.plug(axis)
+            
+            return self
+        end
+        
+        def title(title)
+            @options['main'] = title
+            
+            return self
+        end
+        
+        def color(color)
+            @options['col'] = color
+            
+            return self
+        end
+        
+        def plug(plugin)
+            raise TypeError, "Expected Plugin" unless plugin.is_a?(Plugin)
+            @plugins << plugin
+            
+            return self
+        end
+        
+        def []=(option, value)
+            @options[option] = value
+        end
+        
+        def show()
+            Rust.exclusive do
+                self._show
+                self._run_plugins
+            end
+            
+            return self
+        end
+        
+        def pdf(path, **options)
+            pdf_function = Rust::Function.new("pdf")
+            pdf_function.options = Rust::Options.from_hash(options)
+            pdf_function.options['file'] = path
+            
+            
+            Rust.exclusive do
+                pdf_function.call
+                self._show
+                self._run_plugins
+                Rust._eval("dev.off()")
+            end
+            
+            return self
+        end
+        
+        protected
+        def _show()
+            raise "You are trying to show a BasePlot"
+        end
+        
+        def _run_plugins()
+            @plugins.each do |plugin|
+                plugin._run()
+            end
+            
+            return self
+        end
+        
+        def _augmented_options(options={})
+            result = @options.clone
+            
+            options.each do |key, value|
+                result[key] = value
+            end
+            
+            result.select! { |k, v| v != nil }
+            
+            return result
+        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
+        def initialize
+            @options = Rust::Options.new
+        end
+        
+        def []=(option, value)
+            @options[option] = value
+            
+            return self
+        end
+        
+        protected
+        def _run()
+            raise "You are trying to run an abstract Plugin"
+        end
+    end
+    
+    class Axis < Plugin
+        BELOW = 1
+        LEFT  = 2
+        ABOVE = 3
+        RIGHT = 4
+        
+        def initialize(side)
+            super()
+            
+            self['side'] = side
+            self.at(nil)
+            self.labels(true)
+        end
+        
+        def at(values)
+            self['at'] = values
+            
+            return self
+        end
+        
+        def vertical_labels
+            self['las'] = 2
+            
+            return self
+        end
+        
+        def horizontal_labels
+            self['las'] = 1
+            
+            return self
+        end
+        
+        def labels(value)
+            self['labels'] = value
+            
+            return self
+        end
+        
+        def _run()
+            function = Rust::Function.new("axis")
+            function.options = @options
+            
+            function.call
+            
+            return self
+        end
+    end
+    
+    class Grid < Plugin
+        def initialize
+            super()
+            
+            @x = Float::NAN
+            @y = Float::NAN
+        end
+        
+        def x(value)
+            @x = value
+            
+            return self
+        end
+        
+        def y(value)
+            @y = value
+            
+            return self
+        end
+        
+        def auto_x
+            @x = nil
+            
+            return self
+        end
+        
+        def auto_y
+            @y = nil
+            
+            return self
+        end
+        
+        def hide_x
+            @x = Float::NAN
+            
+            return self
+        end
+        
+        def hide_y
+            @y = Float::NAN
+            
+            return self
+        end
+        
+        def _run()
+            function = Rust::Function.new("grid")
+            
+            function.arguments << @x
+            function.arguments << @y
+            function.options = @options
+            
+            function.call
+            
+            return self
+        end
+    end
+end
+
+module Rust::RBindings
+    def plot(x, y)
+        Rust::Plots::ScatterPlot.new(x, y).show
+    end
+end