rust 0.9 → 0.12

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

@@ -1,6 +1,10 @@
 require_relative 'datatype'
 
 module Rust
+    
+    ##
+    # Mirror of the factor type in R.
+    
     class Factor < RustDatatype
         def self.can_pull?(type, klass)
             return klass == "factor"
@@ -20,11 +24,17 @@ module Rust
             Rust._eval("#{variable_name} <- factor(tmp.values, labels=tmp.levels)")
         end
         
+        ##
+        # Creates a new factor given an array of numeric +values+ and symbolic +levels+.
+        
         def initialize(values, levels)
             @levels = levels.map { |v| v.to_sym }
             @values = values
         end
         
+        ##
+        # Returns the levels of the factor.
+        
         def levels
             @levels
         end
@@ -35,10 +45,17 @@ module Rust
             return @levels == other.levels && self.to_a == other.to_a
         end
         
+        ##
+        # Returns the value of the +i+-th element in the factor.
+        
         def [](i)
             FactorValue.new(@values[i], @levels[@values[i] - 1])
         end
         
+        ##
+        # Sets the +value+ of the +i+-th element in the factor. If it is an Integer, the +value+ must be between 1 and 
+        # the number of levels of the factor. +value+ can be either a FactorValue or a String/Symbol.
+        
         def []=(i, value)
             raise "The given value is outside the factor bounds" if value.is_a?(Integer) && (value < 1 || value > @levels.size)
             
@@ -57,6 +74,9 @@ module Rust
             @values[i] = value
         end
         
+        ##
+        # Returns an array of FactorValue for the values in this factor.
+        
         def to_a
             @values.map { |v| FactorValue.new(v, @levels[v - 1]) }
         end
@@ -76,7 +96,14 @@ module Rust
         end
     end
     
+    ##
+    # Represents a single value in a factor.
+    
     class FactorValue
+        
+        ##
+        # Creates a factor with a given +value+ (numeric) and +level+ (symbolic).
+        
         def initialize(value, level)
             @value = value
             @level = level

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

@@ -1,6 +1,10 @@
 require_relative 'datatype'
 
 module Rust
+    
+    ##
+    # Mirror of the formula type in R.
+    
     class Formula < RustDatatype
         def self.can_pull?(type, klass)
             return klass == "formula" || (klass.is_a?(Array) && klass.include?("formula"))
@@ -24,6 +28,9 @@ module Rust
         attr_reader     :left_part
         attr_reader     :right_part
         
+        ##
+        # Creates a new formula with a given +left_part+ (optional) and +right_part+ (as strings). 
+        
         def initialize(left_part, right_part)
             raise ArgumentError, "Expected string" if left_part && !left_part.is_a?(String)
             raise ArgumentError, "Expected string" if !right_part.is_a?(String)
@@ -46,7 +53,10 @@ module Rust
             return self.to_R.strip
         end
     end
-        
+    
+    ##
+    # Mirror of the call type in R.
+    
     class Call < RustDatatype
         def self.can_pull?(type, klass)
             return klass == "call"
@@ -61,6 +71,9 @@ module Rust
             Rust._eval("#{variable_name} <- str2lang(call.str)")
         end
         
+        ##
+        # Creates a new call with the given +value+ (String).
+        
         def initialize(value)
             @value = value
         end
@@ -74,6 +87,9 @@ module Rust
         end
     end
     
+    ##
+    # Mirror of the environment type in R. Currently not supported.
+    
     class Environment < RustDatatype
         def self.can_pull?(type, klass)
             return type == "environment" && klass == "environment"
@@ -90,25 +106,38 @@ module Rust
         end
     end
     
+    ##
+    # Represents a function call in R. After having set up its name (constructor) and, optionally, its arguments
+    # and options, it can be used the call method to execute it in the R environment.
+    
     class Function
         attr_reader     :name
         attr_reader     :arguments
         attr_reader     :options
         
+        ##
+        # Creates a new function with a given +name+.
+        
         def initialize(name)
             @function = name
             @arguments  = Arguments.new
             @options    = Options.new
         end
         
+        ##
+        # Sets the +options+ (Options type) of the function.
+        
         def options=(options)
             raise TypeError, "Expected Options" unless options.is_a?(Options)
             
             @options = options
         end
         
+        ##
+        # Sets the +arguments+ (Arguments type) of the function.
+        
         def arguments=(arguments)
-            raise TypeError, "Expected Arguments" unless options.is_a?(Arguments)
+            raise TypeError, "Expected Arguments" unless arguments.is_a?(Arguments)
             
             @arguments = arguments
         end
@@ -118,23 +147,21 @@ module Rust
             return "#@function(#{params})"
         end
         
+        ##
+        # Calls the function in the R environment.
+        
         def call
             Rust._eval(self.to_R)
         end
     end
     
-    class SimpleFormula
-        def initialize(dependent, independent)
-            @dependent = dependent
-            @independent = independent
-        end
-        
-        def to_R
-            return "#@dependent ~ #@independent"
-        end
-    end
+    ##
+    # Represents an R variable.
     
     class Variable
+        ##
+        # Creates a variable with the given +name+.
+        
         def initialize(name)
             @name = name
         end
@@ -144,12 +171,18 @@ module Rust
         end
     end
     
+    ##
+    # Represents the arguments of a function in R. Works as an Array of objects.
+    
     class Arguments < Array
         def to_R
             return self.map { |v| v.to_R }.join(", ")
         end
     end
     
+    ##
+    # Represents the options of a function in R. Works as a Hash associating option names to objects.
+    
     class Options < Hash
         def to_R
             return self.map { |k, v| "#{k}=#{v.to_R}" }.join(", ")

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

@@ -1,6 +1,10 @@
 require_relative 'datatype'
 
 module Rust
+    
+    ##
+    # Mirror of the list type in R.
+    
     class List < RustDatatype
         def self.can_pull?(type, klass)
             return type == "list"
@@ -27,12 +31,18 @@ module Rust
             end
         end
         
+        ##
+        # Creates an empty list of a given class (+klass+) and the specified +names+.
+        
         def initialize(klass, names = [])
             @data = {}
             @names = names
             @klass = klass
         end
         
+        ##
+        # Returns the elements for the name +key+.
+        
         def [](key)
             key = get_key(key)
             
@@ -40,12 +50,18 @@ module Rust
         end
         alias :| :[]
         
+        ##
+        # Sets the +value+ for name +key+.
+        
         def []=(key, value)
             key = get_key(key)
             
             return @data[key] = value
         end
         
+        ##
+        # Returns the names of the list.
+        
         def names
             @names
         end

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

@@ -1,6 +1,10 @@
 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")
@@ -27,6 +31,10 @@ module Rust
             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
             
@@ -48,30 +56,45 @@ module Rust
             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 []=(i, j, value)
-            i, j = indices(i, j)
-            
-            @data[i][j] = value
-        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 }

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

@@ -1,6 +1,10 @@
 require_relative 'datatype'
 
 module Rust
+    
+    ##
+    # Mirror for the S4 class in R.
+    
     class S4Class < RustDatatype
         def self.can_pull?(type, klass)
             return type == "S4"
@@ -20,6 +24,9 @@ module Rust
             "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
@@ -27,6 +34,9 @@ module Rust
             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)
             
@@ -36,6 +46,9 @@ module Rust
         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)
             
@@ -44,10 +57,16 @@ module Rust
             end
         end
         
+        ##
+        # Returns the slots.
+        
         def slots
             @slots
         end
         
+        ##
+        # Returns the class name.
+        
         def class_name
             @klass
         end

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

@@ -1,6 +1,10 @@
 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
@@ -9,15 +13,24 @@ module Rust
             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
         
-        def step(step)
+        ##
+        # Sets the step to +step+.
+        
+        def step=(step)
             @step = step
+            
+            return self
         end
+        alias :step :step=
         
         def each
             (@min..@max).step(@step) do |v|

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

@@ -0,0 +1,171 @@
+require_relative '../../../rust'
+
+Rust.prerequisite("ggplot2")
+
+module Rust::Plots::GGPlot
+    def self.default_theme
+        @@theme
+    end
+    
+    def self.default_theme=(theme)
+        @@theme = theme.freeze
+    end
+    
+    class Layer
+        def initialize(function_name, **options)
+            @function_name = function_name
+            @arguments = Rust::Arguments.new
+            @options = Rust::Options.from_hash(options)
+        end
+        
+        def option(key, value)
+            @options[key] = value
+        end
+        
+        def to_R
+            if !block_given?
+                options, arguments = @options, @arguments
+            else
+                options, arguments = yield(@options, @arguments)
+            end
+            
+            options = Rust::Options.from_hash(options) unless options.is_a?(Rust::Options)
+            
+            function = Rust::Function.new(@function_name)
+            function.arguments = arguments if arguments
+            function.options = options if options
+            return function.to_R
+        end
+    end
+    
+    class Aes
+        def initialize(**options)
+            options = options.map { |k, v| [k, v.is_a?(Symbol) ? Rust::Variable.new(v) : v] }.to_h
+            @options = Rust::Options.from_hash(options)
+        end
+        
+        def to_R
+            function = Rust::Function.new("aes")
+            function.options = @options if @options
+            return function.to_R
+        end
+    end
+    
+    class Plot
+        attr_accessor   :theme
+        attr_accessor   :aes
+        
+        def initialize(data, aes = nil)
+            @layers = []
+            
+            @data = data
+            @aes = aes
+            @theme = Rust::Plots::GGPlot.default_theme
+        end
+        
+        def layer(layer)
+            @layers << layer
+        end
+        
+        def show()
+            Rust.exclusive do
+                dataset_name = nil
+                if @data
+                    dataset_name = "ggplotter.data"
+                    @data.load_in_r_as(dataset_name)
+                end
+                r = self.to_R(dataset_name)
+                Rust._eval(r)
+            end
+        end
+
+        def save(filename, **options)
+            Rust.exclusive do 
+                dataset_name = nil
+                if @data
+                    dataset_name = "ggplotter.data"
+                    @data.load_in_r_as(dataset_name)
+                end
+                r = self.to_R(dataset_name)
+                Rust._eval("ggplot.latest <- #{r}")
+                save = Rust::Function.new("ggsave")
+                save.arguments = Rust::Arguments.new([Rust::Variable.new("ggplot.latest")])
+                save.options = Rust::Options.from_hash({file: filename}.merge(options))
+                save.call
+            end
+        end
+        
+        def to_R(data_set_name="ggplotter.data")
+            function = Rust::Function.new("ggplot")
+            function.arguments = Rust::Arguments.new
+            function.arguments << (data_set_name ? Rust::Variable.new(data_set_name) : nil)
+            function.arguments << @aes if @aes
+            
+            result = function.to_R
+            result += " + " + @theme.to_R
+            @layers.each do |layer|
+                result += " + " + layer.to_R
+            end
+            
+            return result
+        end
+        
+        def <<(others)
+            if others.is_a?(Array) && others.all? { |o| o.is_a?(Layer) }
+                @layers += others
+            elsif others.is_a?(Layer)
+                @layers << others
+            else
+                raise ArgumentError, "Expected Layer or Array of Layers"
+            end
+            
+            return self
+        end
+        
+        def +(others)
+            copy = self.deep_clone
+            copy << others
+            return copy
+        end
+        
+        def inspect(show = true)
+            self.show if show
+            return super()
+        end
+    end
+    
+    class Labels < Layer
+        def initialize(**options)
+            super("labs", **options)
+        end
+    end
+    
+    class FlipCoordinates < Layer
+        def initialize(**options)
+            super("coord_flip", **options)
+        end
+    end
+end
+
+module Rust::RBindings
+    def ggplot(*arguments)
+        Rust::Plots::GGPlot::Plot.new(*arguments)
+    end
+    
+    def aes(**options)
+        Rust::Plots::GGPlot::Aes.new(**options)
+    end
+    
+    def labs(**options)
+        Rust::Plots::GGPlot::Labels.new(**options)
+    end
+    alias :labels :labs
+    
+    def coord_flip(**options)
+        Rust::Plots::GGPlot::FlipCoordinates.new(**options)
+    end
+end
+
+def bind_ggplot!
+    include Rust::Plots::GGPlot
+end

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

@@ -0,0 +1,83 @@
+require_relative 'core'
+
+module Rust::Plots::GGPlot
+    class Geom < Layer
+        def initialize(type, arguments = [], **options)
+            super("geom_#{type}", **options)
+            @type = type
+            @arguments = Rust::Arguments.new(arguments)
+        end
+    end
+    
+    class GeomPoint < Geom
+        def initialize(arguments = [], **options)
+            super("point", arguments, **options)
+        end
+    end
+    
+    class GeomLine < Geom
+        def initialize(arguments = [], **options)
+            super("line", arguments, **options)
+        end
+    end
+    
+    class GeomCol < Geom
+        def initialize(arguments = [], **options)
+            super("col", arguments, **options)
+        end
+    end
+    
+    class GeomBoxplot < Geom
+        def initialize(arguments = [], **options)
+            super("boxplot", arguments, **options)
+        end
+    end
+    
+    class GeomBar < Geom
+        def initialize(arguments = [], **options)
+            super("bar", arguments, **options)
+        end
+    end
+    
+    class GeomHistogram < Geom
+        def initialize(arguments = [], **options)
+            super("histogram", arguments, **options)
+        end
+    end
+    
+    class GeomDensity < Geom
+        def initialize(arguments = [], **options)
+            super("density", arguments, **options)
+        end
+    end
+end
+
+module Rust::RBindings
+    def geom_point(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomPoint.new(*arguments, **options)
+    end
+    
+    def geom_line(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomLine.new(*arguments, **options)
+    end
+    
+    def geom_col(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomCol.new(*arguments, **options)
+    end
+    
+    def geom_bar(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomBar.new(*arguments, **options)
+    end
+    
+    def geom_boxplot(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomBoxplot.new(*arguments, **options)
+    end
+    
+    def geom_histogram(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomHistogram.new(*arguments, **options)
+    end
+    
+    def geom_density(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomDensity.new(*arguments, **options)
+    end
+end