rust 0.4 → 0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca9e5aaa6bcfff9d1b261c5a3ced5cf74b7731085b4b094dba55df72884aca9a
-  data.tar.gz: 8c90363b44a0c95abc9610fb78c3c632c6ae4265ad2260ff7e9740777245f63e
+  metadata.gz: fe8f5c3e0753395fe3925f7a64eab0476308df329a9c9d594c74d1e568419204
+  data.tar.gz: 9f5371713565e77777deba19ba745bb358e0a23dfad6fb562e3940cf90cf8f1e
 SHA512:
-  metadata.gz: 0ca17e2c0dda2188138f11e1ae4becaa8a5c4b0d2cc12273775b9ade1fefbc860f3ccee2251fbe353b9dbde55eded960e8cf26642af042070d979ed192b332e3
-  data.tar.gz: 28dacd36f814acf51d222c8e746f65b94ef53ab5f24902ba6f654b05267c926e8db03cca82a876ca1183f55293da96d60ec862c5bfa26f6abd430d1f5e998709
+  metadata.gz: abf20b1c4cea07089c27ab886ff640886ff4e5f74d2b964b3ab959d413cdf1d34d72055e1d7141e3585df5adcdfbf5a53716d3cf7ca7b352ee02d4e39dda020b
+  data.tar.gz: c6c97cc64a50449bcf97a5d584f6a17b4e05762f79321ed9dcccfee496b567933f3fb0b4e8908c4f8029aeb0683cb7d86863586f7c200979f98911aa5b82c258

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,15 +1,32 @@
-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 = {}
+            result = DataFrameHash.new
             Dir.glob(pattern).each do |filename|
                 result[filename] = CSV.read(filename, **options)
             end
             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,14 +62,18 @@ 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)
             
             write_headers = options[:headers] != false
-            options[:headers] = dataframe.column_names if options[:headers] == nil
+            options[:headers] = dataframe.column_names unless options[:headers]
             
             hash = {}
-            labels = nil
             ::CSV.open(filename, 'w', write_headers: write_headers, **options) do |csv|
                 dataframe.each do |row|
                     csv << row
@@ -93,3 +114,13 @@ module Rust
         end
     end
 end
+
+module Rust::RBindings
+    def read_csv(filename, **options)
+        Rust::CSV.read(filename, **options)
+    end
+    
+    def write_csv(filename, dataframe, **options)
+        Rust::CSV.write(filename, dataframe, **options)
+    end
+end

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