rust 0.7 → 0.11

data/lib/rust/core/types/matrix.rb

@@ -0,0 +1,155 @@
+require_relative 'datatype'
+
+module Rust
+    
+    ##
+    # Mirror of the matrix type in R.
+    
+    class Matrix < RustDatatype
+        def self.can_pull?(type, klass)
+            return klass.is_a?(Array) && klass.include?("matrix")
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            if Rust._pull("length(#{variable})") == 1
+                core = ::Matrix[[Rust._pull("#{variable}[1]")]]
+            else
+                core = Rust._pull(variable)
+            end
+            row_names = [Rust["rownames(#{variable})"]].flatten
+            column_names = [Rust["colnames(#{variable})"]].flatten
+            
+            row_names = nil if row_names.all? { |v| v == nil }
+            column_names = nil if column_names.all? { |v| v == nil }
+            
+            Matrix.new(core, row_names, column_names)
+        end
+        
+        def load_in_r_as(variable_name)
+            matrix = ::Matrix[*@data]
+            
+            Rust[variable_name] = matrix
+        end
+        
+        ##
+        # Creates a new matrix with the given +data+ (Ruby Matrix). Optionally, +row_names+ and +column_names+ can 
+        # be specified.
+        
+        def initialize(data, row_names = nil, column_names = nil)
+            @data = data.clone
+            
+            @row_names = row_names
+            @column_names = column_names
+            
+            if @data.is_a?(::Matrix)
+                @data = @data.row_vectors.map { |v| v.to_a }
+            end
+            
+            if self.flatten.size == 0
+                raise "Empty matrices are not allowed"
+            else
+                raise TypeError, "Expected array of array" unless @data.is_a?(Array) || @data[0].is_a?(Array)
+                raise TypeError, "Only numeric matrices are supported" unless self.flatten.all? { |e| e.is_a?(Numeric) }
+                raise "All the rows must have the same size" unless @data.map { |row| row.size }.uniq.size == 1
+                raise ArgumentError, "Expected row names #@row_names to match the number of rows in #{self.inspect}" if @row_names && @row_names.size != self.rows
+                raise ArgumentError, "Expected column names #@column_names to match the number of columns in #{self.inspect}" if @column_names && @column_names.size != self.cols
+            end
+        end
+        
+        ##
+        # Returns the matrix element at row +i+ and column +j+.
+        
+        def [](i, j)
+            i, j = indices(i, j)
+            
+            return @data[i][j]
+        end
+        
+        ##
+        # Sets the matrix element at row +i+ and column +j+ with +value+.
+        
+        def []=(i, j, value)
+            i, j = indices(i, j)
+            
+            @data[i][j] = value
+        end
+        
+        ##
+        # Returns the number of rows.
+        
+        def rows
+            @data.size
+        end
+        
+        ##
+        # Returns the number of columns.
+        
+        def cols
+            @data[0].size
+        end
+        
+        ##
+        # Returns a flattened version of the matrix (Array).
+        
+        def flatten
+            return @data.flatten
+        end
+        
+        def inspect
+            row_names = @row_names || (0...self.rows).to_a.map { |v| v.to_s }
+            column_names = @column_names || (0...self.cols).to_a.map { |v| v.to_s }
+            
+            separator = " | "
+            col_widths = column_names.map do |colname| 
+                [
+                    colname, 
+                    (
+                        [colname ? colname.length : 1] + 
+                        @data.map {|r| r[column_names.index(colname)]}.map { |e| e.inspect.length }
+                    ).max
+                ]
+            end.to_h
+            col_widths[:rowscol] = row_names.map { |rowname| rowname.length }.max + 3
+            
+            result = ""
+            result << "-" * (col_widths.values.sum + ((col_widths.size - 1) * separator.length)) + "\n"
+            result << (" " * col_widths[:rowscol]) + column_names.map { |colname| (" " * (col_widths[colname] - colname.length)) + colname }.join(separator) + "\n"
+            result << "-" * (col_widths.values.sum + ((col_widths.size - 1) * separator.length)) + "\n"
+            
+            @data.each_with_index do |row, i|
+                row_name = row_names[i]
+                row = column_names.zip(row)
+                
+                index_part = "[" + (" " * (col_widths[:rowscol] - row_name.length - 3)) + "#{row_name}] "
+                row_part   = row.map { |colname, value| (" " * (col_widths[colname] - value.inspect.length)) + value.inspect }.join(separator)
+                
+                result << index_part + row_part + "\n"
+            end
+            
+            result << "-" * (col_widths.values.sum + ((col_widths.size - 1) * separator.length))
+            
+            return result
+        end
+        
+        private
+        def indices(i, j)
+            if i.is_a?(String)
+                ri = @row_names.index(i)
+                raise ArgumentError, "Can not find row #{i}" unless ri
+                i = ri
+            end
+            
+            if j.is_a?(String)
+                rj = @column_names.index(j)
+                raise ArgumentError, "Can not find column #{j}" unless rj
+                j = rj
+            end
+            
+            raise ArgumentError, "Expected i and j to be both integers or strings" unless i.is_a?(Integer) && j.is_a?(Integer)
+            raise "Wrong i" unless i.between?(0, @data.size - 1)
+            raise "Wrong j" unless j.between?(0, @data[0].size - 1)
+            
+            return [i, j]
+        end
+    end
+end

data/lib/rust/core/types/s4class.rb

@@ -0,0 +1,78 @@
+require_relative 'datatype'
+
+module Rust
+    
+    ##
+    # Mirror for the S4 class in R.
+    
+    class S4Class < RustDatatype
+        def self.can_pull?(type, klass)
+            return type == "S4"
+        end
+        
+        def self.pull_variable(variable, type, klass)
+            slots = [Rust._pull("names(getSlots(\"#{klass}\"))")].flatten
+            
+            return S4Class.new(variable, klass, slots)
+        end
+        
+        def load_in_r_as(variable_name)
+            Rust._eval("#{variable_name} <- #{self.r_mirror}")
+        end
+        
+        def r_hash
+            "immutable"
+        end
+        
+        ##
+        # Creates a new S4 element, given its +variable_name+, class name (+klass+), and +slots+.
+        
+        def initialize(variable_name, klass, slots)
+            @klass = klass
+            @slots = slots
+            
+            self.r_mirror_to(variable_name)
+        end
+        
+        ##
+        # Returns the slot +key+ for the class name (+klass+).
+        
+        def [](key)
+            raise ArgumentError, "Unknown slot `#{key}` for class `#@klass`" unless @slots.include?(key)
+            
+            Rust.exclusive do
+                return Rust["#{self.r_mirror}@#{key}"]
+            end
+        end
+        alias :| :[]
+        
+        ##
+        # Returns the slot +key+ for the class name (+klass+) with +value+.
+        
+        def []=(key, value)
+            raise ArgumentError, "Unknown slot `#{key}` for class `#@klass`" unless @slots.include?(key)
+            
+            Rust.exclusive do
+                return Rust["#{self.r_mirror}@#{key}"] = value
+            end
+        end
+        
+        ##
+        # Returns the slots.
+        
+        def slots
+            @slots
+        end
+        
+        ##
+        # Returns the class name.
+        
+        def class_name
+            @klass
+        end
+        
+        def inspect
+            return "<S4 instance of #@klass, with slots #@slots>"
+        end
+    end
+end

data/lib/rust/core/types/utils.rb

@@ -0,0 +1,122 @@
+require_relative 'datatype'
+
+module Rust
+    
+    ##
+    # Represents a sequence of values in R (through a call to the seq function).
+    
+    class Sequence < RustDatatype
+        attr_reader :min
+        attr_reader :max
+        
+        def self.can_pull?(type, klass)
+            return false
+        end
+        
+        ##
+        # Creates a new sequence from +min+ to +max+ with a given +step+ (default = 1).
+        
+        def initialize(min, max, step=1)
+            @min = min
+            @max = max
+            @step = step
+        end
+        
+        ##
+        # Sets the step to +step+.
+        
+        def step=(step)
+            @step = step
+            
+            return self
+        end
+        alias :step :step=
+        
+        def each
+            (@min..@max).step(@step) do |v|
+                yield v
+            end
+        end
+        
+        def to_a
+            result = []
+            self.each do |v|
+                result << v
+            end
+            return result
+        end
+        
+        def to_R
+            "seq(from=#@min, to=#@max, by=#@step)"
+        end
+        
+        def load_in_r_as(variable_name)
+            Rust._eval("#{variable_name} <- #{self.to_R}")
+        end
+    end
+    
+    class MathArray < Array
+        def -(other)
+            raise ArgumentError, "Expected array or numeric" if !other.is_a?(::Array) && !other.is_a?(Numeric)
+            raise ArgumentError, "The two arrays must have the same size" if other.is_a?(::Array) && self.size != other.size
+            
+            result = self.clone
+            other = [other] * self.size if other.is_a?(Numeric)
+            for i in 0...self.size
+                result[i] -= other[i]
+            end
+            
+            return result
+        end
+        
+        def *(other)
+            raise ArgumentError, "Expected array or numeric" if !other.is_a?(::Array) && !other.is_a?(Numeric)
+            raise ArgumentError, "The two arrays must have the same size" if other.is_a?(::Array) && self.size != other.size
+            
+            result = self.clone
+            other = [other] * self.size if other.is_a?(Numeric)
+            for i in 0...self.size
+                result[i] *= other[i]
+            end
+            
+            return result
+        end
+                
+        def +(other)
+            raise ArgumentError, "Expected array or numeric" if !other.is_a?(::Array) && !other.is_a?(Numeric)
+            raise ArgumentError, "The two arrays must have the same size" if other.is_a?(::Array) && self.size != other.size
+            
+            result = self.clone
+            other = [other] * self.size if other.is_a?(Numeric)
+            for i in 0...self.size
+                result[i] += other[i]
+            end
+            
+            return result
+        end
+        
+        def /(other) #/# <- this comment is just to recover the syntax highlighting bug in Kate
+            raise ArgumentError, "Expected array or numeric" if !other.is_a?(::Array) && !other.is_a?(Numeric)
+            raise ArgumentError, "The two arrays must have the same size" if other.is_a?(::Array) && self.size != other.size
+            
+            result = self.clone
+            other = [other] * self.size if other.is_a?(Numeric)
+            for i in 0...self.size
+                result[i] /= other[i]
+            end
+            
+            return result
+        end
+        
+        def **(other)
+            raise ArgumentError, "Expected numeric" if !other.is_a?(Numeric)
+            
+            result = self.clone
+            for i in 0...self.size
+                result[i] = result[i] ** other
+            end
+            
+            return result
+        end
+    end
+end

data/lib/rust/core.rb

@@ -0,0 +1,7 @@
+require_relative 'core/rust'
+require_relative 'core/csv'
+
+self_path = File.expand_path(__FILE__)
+Dir.glob(File.join(File.dirname(self_path), "core/types/*.rb")).each do |lib|
+    require_relative lib
+end

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/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/models/anova.rb

@@ -0,0 +1,77 @@
+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")
+        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
+        
+        ##
+        # 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
+                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
+        
+        ##
+        # 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
+                    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