rust 0.7 → 0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35c41ec98f5b286ef597096152249f19825a27bc33030e85ea196df8b778d3b1
-  data.tar.gz: 48b2e61f707ebcd05fa5f593016c8c0fb4b9d1e58751dd5deae83715583bd978
+  metadata.gz: 77dee9cb8c4a1e2894a8054fab8dbf140b8f6a4aed8ef38a60b41564fb5e8e69
+  data.tar.gz: c9bf14d2239f464cf73ffaee86bcbfe9155a323269eff1b34b7bcd1272c46d36
 SHA512:
-  metadata.gz: b0cc1289721d52cd376e0a242c2be419ea511f03a0fdd42c4c7a1973cde24e8dfc467e9d355693f85632cccb98af6986777aa020b715db5f06aa88a63d154ea0
-  data.tar.gz: 4c91c808773dcd04913a594cfcaa7956318908e6d590ebec1d9a04beef18986adc70a3c5e480c39bdc9f753b5edf920a1939208b8b530ccfc67124ac153a4804
+  metadata.gz: a648f440574e7734f979c0ec5d65bc9594202cfe88414517dcc50482e391360809ced88bbc0b825f548dfd23dd2b9dfe47b71cabbd216249d992d8a18d14717c
+  data.tar.gz: 1b999d94b96c05a0615ff05b3e1588c4a8e822baebba57055ae041a6fe2c7d0355d747e3c88973c9325046c59c4eff013b27336d95297c8c0e1cc06f515b2f27

data/bin/ruby-rust

@@ -0,0 +1,3 @@
+#!/usr/bin/ruby
+
+system "RUBY_RUST_BINDING=1 irb -r \"rust\""

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

@@ -1,7 +1,17 @@
-require_relative 'rust-core'
+require_relative '../core'
+require 'csv'
 
 module Rust
+    
+    ##
+    # Class that handles CSVs (both loading and saving).
+    
     class CSV
+        
+        ##
+        # Reads a +pattern+ of CSVs (glob-style pattern) and returns a map containing as keys the filenames of the
+        # loaded CSVs and as values the corresponding data-frames. Options can be specified (see #read).
+        
         def self.read_all(pattern, **options)
             result = DataFrameHash.new
             Dir.glob(pattern).each do |filename|
@@ -10,6 +20,13 @@ module Rust
             return result
         end
         
+        ##
+        # Reads the CSV at +filename+. Options can be specified, such as:
+        # - headers => set to true if the first row contains the headers, false otherwise;
+        # - infer_numbers => if a column contains only numbers, the values are transformed into floats; true by default;
+        # - infer_integers => if infer_numbers is active, it distinguishes between integers and floats;
+        # The other options are the ones that can be used in the function R function "read.csv".
+        
         def self.read(filename, **options)
             hash = {}
             labels = nil
@@ -45,6 +62,11 @@ module Rust
             return result
         end
         
+        ##
+        # Writes the +dataframe+ as a CSV at +filename+. Options can be specified, such as:
+        # - headers => set to true if the first row should contain the headers, false otherwise;
+        # The other options are the ones that can be used in the function R function "read.csv".
+        
         def self.write(filename, dataframe, **options)
             raise TypeError, "Expected Rust::DataFrame" unless dataframe.is_a?(Rust::DataFrame)
             

data/lib/rust/core/rust.rb

@@ -0,0 +1,221 @@
+require 'code-assertions'
+require 'stringio'
+require 'rinruby'
+
+##
+# Basic module for the Rust package. It includes a series of sub-modules that provide specific features, such as
+# statistical hypothesis tests, plots, and so on.
+
+module Rust
+    CLIENT_MUTEX = Mutex.new
+    R_MUTEX      = Mutex.new
+    
+    R_ENGINE     = RinRuby.new(echo: false)
+    
+    private_constant    :R_ENGINE
+    private_constant    :R_MUTEX
+    private_constant    :CLIENT_MUTEX
+    
+    @@debugging = $RUST_DEBUG || false
+    @@in_client_mutex = false
+    
+    ##
+    # Sets the debug mode. Any call to R will be written on the standard output.
+    
+    def self.debug
+        @@debugging = true
+    end
+    
+    ##
+    # Checks if the debug mode is active.
+    
+    def self.debug?
+        return @@debugging
+    end
+    
+    ##
+    # Runs the given block with a mutex. It is mandatory to run any R command with this method. 
+    
+    def self.exclusive
+        result = nil
+        CLIENT_MUTEX.synchronize do
+            @@in_client_mutex = true
+            result = yield
+            @@in_client_mutex = false
+        end
+        return result
+    end
+    
+    ##
+    # Sets a variable in the R environment with a given value.
+    #
+    # Raises an error if the value can not be translated into an R object.
+    #
+    # Example: Rust['a'] = 0.
+    
+    def self.[]=(variable, value)
+        if value.is_a?(RustDatatype)
+            value.load_in_r_as(variable.to_s)
+        elsif value.is_a?(String) || value.is_a?(Numeric) || value.is_a?(Array) || value.is_a?(::Matrix)
+            R_ENGINE.assign(variable, value)
+        else
+            raise "Trying to assign #{variable} with #{value.class}; expected RustDatatype, String, Numeric, or Array"
+        end
+    end
+    
+    ##
+    # Retrieves the value of a variable from the R environment.
+    #
+    # Example: Rust['a']
+    
+    def self.[](variable)
+        return RustDatatype.pull_variable(variable)
+    end
+    
+    def self._eval_big(r_command, return_warnings = false)
+        r_command = r_command.join("\n") if r_command.is_a?(Array)
+        
+        self._rexec(r_command, return_warnings) do |cmd|
+            result = true
+            instructions = cmd.lines
+            
+            while instructions.size > 0
+                current_command = ""
+                
+                while (instructions.size > 0) && (current_command.length + instructions.first.length < 10000)
+                    current_command << instructions.shift
+                end
+                
+                result &= R_ENGINE.eval(current_command)
+            end
+            
+            result
+        end
+    end
+    
+    def self._pull(r_command, return_warnings = false)
+        self._rexec(r_command, return_warnings) { |cmd| R_ENGINE.pull(cmd) }
+    end
+    
+    def self._eval(r_command, return_warnings = false)
+        self._rexec(r_command, return_warnings) { |cmd| R_ENGINE.eval(cmd) }
+    end
+    
+    def self._rexec(r_command, return_warnings = false)
+        puts "Calling _rexec with command: #{r_command}" if @@debugging
+        R_MUTEX.synchronize do
+            assert("This command must be executed in an exclusive block") { @@in_client_mutex }
+            
+            result = nil
+            begin
+                $stdout = StringIO.new
+                if return_warnings
+                    R_ENGINE.echo(true, true)
+                else
+                    R_ENGINE.echo(false, false)
+                end
+                result = yield(r_command)
+            ensure
+                R_ENGINE.echo(false, false)
+                warnings = $stdout.string
+                $stdout = STDOUT
+            end
+            
+            if return_warnings
+                puts " Got #{warnings.size} warnings, with result #{result.inspect[0...100]}" if @@debugging
+                return result, warnings.lines.map { |w| w.strip.chomp }
+            else
+                puts " Result: #{result.inspect[0...100]}" if @@debugging
+                return result
+            end
+        end
+    end
+    
+    ##
+    # Checks if the given +name+ library can be used. Returns true if it is available, false otherwise.
+    
+    def self.check_library(name)
+        self.exclusive do
+            result, _ = self._pull("require(\"#{name}\", character.only = TRUE)", true)
+            return result
+        end
+    end
+    
+    ##
+    # Loads the given +name+ library.
+    
+    def self.load_library(name)
+        self.exclusive do
+            self._eval("library(\"#{name}\", character.only = TRUE)")
+        end
+        
+        return nil
+    end
+    
+    ##
+    # Installs the given +name+ library and its dependencies.
+    
+    def self.install_library(name)
+        self.exclusive do
+            self._eval("install.packages(\"#{name}\", dependencies = TRUE)")
+        end
+        
+        return nil
+    end
+    
+    ##
+    # Installs the +library+ library if it is not available and loads it.
+    
+    def self.prerequisite(library)
+        self.install_library(library) unless self.check_library(library)
+        self.load_library(library)
+    end
+    
+    ##
+    # Ask for help on a given +mod+.
+    
+    def self.help!(mod = nil)
+        unless mod
+            puts "You have the following modules:"
+            Rust.constants.map { |c| Rust.const_get(c) }.select { |c| c.class == Module }.each do |mod|
+                puts "\t- #{mod}"
+            end
+            puts "Run \"help! {module}\" for more detailed information about the module"
+        else
+            if mod.methods.include?(:help!)
+                mod.help!
+            else
+                puts "Sorry, no help available for #{mod}"
+            end
+        end
+    end
+end
+
+##
+# Module that contains methods that allow to call R functions faster. Such methods have names resembling the ones
+# available in R (e.g., cor, wilcox_test).
+
+module Rust::RBindings
+    def data_frame(*args)
+        Rust::DataFrame.new(*args)
+    end
+end
+
+module Rust::TestCases
+    def self.sample_dataframe(columns, size=100)
+        result = Rust::DataFrame.new(columns)
+        size.times do |i|
+            result << columns.map { |c| yield i, c }
+        end
+        return result
+    end
+end
+
+##
+# Shortcut for including the RBinding module
+
+def bind_r!
+    include Rust::RBindings
+end
+
+bind_r! if ENV['RUBY_RUST_BINDING'] == '1'

data/lib/rust/core/types/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