rust 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fca0e67fdbbd71271d8baf0ab5c1b7cee895dd6f546699ca420bd0fa9ceb8a83
+  data.tar.gz: d0c30431caacfcd06744d8973ee2938d3e8b44297624d6dcb514fde1280a43cd
+SHA512:
+  metadata.gz: 5004a2514605db69f616eeb25c3d89eb7ac6b6702be97a15202c0b4bc9731e4e0b55347a256dc7123c85c7342be3af096689a88a07b1c0489f88a86aacfef982
+  data.tar.gz: 1e969dca0511a2ac803c1e4369b6471641af4850b53663293dd69cd1009ecec352570173a484fe91b9ed6c822052592fde7a6cb165dc01eaed6efabea3a693cd

data/lib/rust-core.rb

@@ -0,0 +1,66 @@
+require 'code-assertions'
+require 'stringio'
+require 'rinruby'
+
+module Rust
+    CLIENT_MUTEX = Mutex.new
+    R_MUTEX      = Mutex.new
+    
+    R_ENGINE     = RinRuby.new(echo: false)
+    
+    @@in_client_mutex = false
+    
+    def self.exclusive
+        CLIENT_MUTEX.synchronize do
+            @@in_client_mutex = true
+            yield
+            @@in_client_mutex = false
+        end
+    end
+    
+    def self._pull(r_command, return_warnings = false)
+        R_MUTEX.synchronize  do
+            assert("This command must be executed in an exclusive block") { @@in_client_mutex }
+            
+            $stdout = StringIO.new
+            if return_warnings
+                R_ENGINE.echo(true, true)
+            else
+                R_ENGINE.echo(false, false)
+            end
+            result = R_ENGINE.pull(r_command)
+            R_ENGINE.echo(false, false)
+            warnings = $stdout.string
+            $stdout = STDOUT
+            
+            if return_warnings
+                return result, warnings.lines.map { |w| w.strip.chomp }
+            else
+                return result
+            end
+        end
+    end
+    
+    def self._eval(r_command, return_warnings = false)
+        R_MUTEX.synchronize do
+            assert("This command must be executed in an exclusive block") { @@in_client_mutex }
+            
+            $stdout = StringIO.new
+            if return_warnings
+                R_ENGINE.echo(true, true)
+            else
+                R_ENGINE.echo(false, false)
+            end
+            result = R_ENGINE.eval(r_command)
+            R_ENGINE.echo(false, false)
+            warnings = $stdout.string
+            $stdout = STDOUT
+            
+            if return_warnings
+                return result, warnings.lines.map { |w| w.strip.chomp }
+            else
+                return result
+            end
+        end
+    end
+end

data/lib/rust-descriptive.rb

@@ -0,0 +1,59 @@
+require 'code-assertions'
+
+require_relative 'rust-core'
+
+module Rust::Descriptive
+    class << self
+        def mean(data)
+            raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
+            
+            return data.sum.to_f / data.size
+        end
+        
+        def standard_deviation(data)
+            raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
+            
+            # TODO implement
+        end
+        alias :sd     :standard_deviation
+        alias :stddev :standard_deviation
+        
+        def variance(data)
+            raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
+            
+            # TODO implement
+        end
+        alias :var     :variance
+        
+        def median(data)
+            raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
+            
+            sorted = data.sort
+            if data.size == 0
+                return Float::NAN
+            elsif data.size.odd?
+                return sorted[data.size / 2]
+            else
+                i = (data.size / 2)
+                return (sorted[i - 1] + sorted[i]) / 2.0
+            end
+        end
+        
+        def quantile(data, percentiles=[0.0, 0.25, 0.5, 0.75, 1.0])
+            raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
+            raise TypeError, "Expecting Array of numerics" if !percentiles.is_a?(Array) || !percentiles.all? { |e| e.is_a?(Numeric) }
+            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
+                
+                call_result = Rust._pull("quantile(data, percs)")
+                assert { call_result.is_a?(Array) }
+                assert { call_result.size == percentiles.size }
+                
+                return percentiles.zip(call_result).to_h
+            end
+        end
+    end
+end

data/lib/rust-effsize.rb

@@ -0,0 +1,79 @@
+require 'code-assertions'
+
+Rust.exclusive do
+    Rust._eval("library(effsize)")
+end
+
+module Rust::EffectSize
+    class Result
+        attr_accessor   :name
+        attr_accessor   :estimate
+        attr_accessor   :confidence_interval
+        attr_accessor   :confidence_level
+        attr_accessor   :magnitude
+        
+        def to_s
+            return "#{name} = #{estimate} (#{magnitude}) [#{confidence_interval.min}, #{confidence_interval.max}]"
+        end
+    end
+end
+
+module Rust::EffectSize::CliffDelta
+    class << self
+        def compute(d1, d2)
+            raise TypeError, "Expecting Array of numerics" if !d1.is_a?(Array) || !d1.all? { |e| e.is_a?(Numeric) }
+            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._eval("result = cliff.delta(a, 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
+                
+                return result
+            end
+        end
+    end
+end
+
+module Rust::EffectSize::CohenD
+    class << self
+        def compute(d1, d2)
+            raise TypeError, "Expecting Array of numerics" if !d1.is_a?(Array) || !d1.all? { |e| e.is_a?(Numeric) }
+            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._eval("result = cohen.d(a, 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
+                
+                return result
+            end
+        end
+    end
+end
+
+module Rust::RBindings
+    def cliff_delta(d1, d2)
+        Rust::EffectSize::CliffDelta.compute(d1, d2)
+    end
+    
+    def cohen_d(d1, d2, **args)
+        Rust::EffectSize::CohenD.compute(d1, d2)
+    end
+end

data/lib/rust-tests.rb

@@ -0,0 +1,144 @@
+require_relative 'rust-core'
+
+module Rust::StatisticalTests
+    class Result
+        attr_accessor   :name
+        attr_accessor   :statistics
+        attr_accessor   :pvalue
+        attr_accessor   :exact
+        attr_accessor   :alpha
+        
+        def initialize
+            @statistics = {}
+        end
+        
+        def [](name)
+            return @statistics[name.to_sym]
+        end
+        
+        def []=(name, value)
+            @statistics[name.to_sym] = value
+        end
+        
+        def significant
+            pvalue < alpha
+        end
+        
+        def to_s
+            return "#{name}. P-value = #{pvalue} " +
+                    "(#{significant ? "significant" : "not significant"} w/ alpha = #{alpha}); " + 
+                    "#{ statistics.map { |k, v| k.to_s + " -> " + v.to_s  }.join(", ") }." +
+                    (!exact ? " P-value is not exact." : "")
+        end
+    end
+end
+
+module Rust::StatisticalTests::Wilcoxon
+    class << self
+        def paired(d1, d2, alpha = 0.05)
+            raise TypeError, "Expecting Array of numerics" if !d1.is_a?(Array) || !d1.all? { |e| e.is_a?(Numeric) }
+            raise TypeError, "Expecting Array of numerics" if !d2.is_a?(Array) || !d2.all? { |e| e.is_a?(Numeric) }
+            raise "The two distributions have different size" if d1.size != d2.size
+            
+            Rust.exclusive do
+                Rust::R_ENGINE.a = d1
+                Rust::R_ENGINE.b = d2
+                
+                _, warnings = Rust._eval("result = wilcox.test(a, b, alternative='two.sided', paired=T)", true)
+                result = Rust::StatisticalTests::Result.new
+                result.name      = "Wilcoxon Signed-Rank test"
+                result.pvalue    = Rust._pull("result$p.value")
+                result[:w]       = Rust._pull("result$statistic")
+                result.exact     = !warnings.include?("cannot compute exact p-value with zeroes")
+                result.alpha     = alpha
+            
+                return result
+            end
+        end
+        
+        def unpaired(d1, d2, alpha = 0.05)
+            raise TypeError, "Expecting Array of numerics" if !d1.is_a?(Array) || !d1.all? { |e| e.is_a?(Numeric) }
+            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
+                
+                _, warnings = Rust._eval("result = wilcox.test(a, b, alternative='two.sided', paired=F)", true)
+                result = Rust::StatisticalTests::Result.new
+                result.name      = "Mann–Whitney U test, Wilcoxon Ranked-Sum test"
+                result.pvalue    = Rust._pull("result$p.value")
+                result[:w]       = Rust._pull("result$statistic")
+                result.exact     = !warnings.include?("cannot compute exact p-value with ties")
+                result.alpha     = alpha
+                
+                return result
+            end
+        end
+    end
+end
+    
+module Rust::StatisticalTests::T
+    class << self
+        def paired(d1, d2, alpha = 0.05)
+            raise TypeError, "Expecting Array of numerics" if !d1.is_a?(Array) || !d1.all? { |e| e.is_a?(Numeric) }
+            raise TypeError, "Expecting Array of numerics" if !d2.is_a?(Array) || !d2.all? { |e| e.is_a?(Numeric) }
+            raise "The two distributions have different size" if d1.size != d2.size
+            
+            Rust.exclusive do
+                Rust::R_ENGINE.a = d1
+                Rust::R_ENGINE.b = d2
+                
+                warnings = Rust._eval("result = t.test(a, b, alternative='two.sided', paired=T)")
+                result = Rust::StatisticalTests::Result.new
+                result.name      = "Paired t-test"
+                result.pvalue    = Rust._pull("result$p.value")
+                result[:t]       = Rust._pull("result$statistic")
+                result.exact     = true
+                result.alpha     = alpha
+                
+                return result
+            end
+        end
+        
+        def unpaired(d1, d2, alpha = 0.05)
+            raise TypeError, "Expecting Array of numerics" if !d1.is_a?(Array) || !d1.all? { |e| e.is_a?(Numeric) }
+            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._eval("result = t.test(a, b, alternative='two.sided', paired=F)")
+                result = Rust::StatisticalTests::Result.new
+                result.name      = "Welch Two Sample t-test"
+                result.pvalue    = Rust._pull("result$p.value")
+                result[:t]       = Rust._pull("result$statistic")
+                result.exact     = true
+                result.alpha     = alpha
+                
+                return result
+            end
+        end
+    end
+end
+
+module Rust::RBindings
+    def wilcox_test(d1, d2, **args)
+        paired = args[:paired] || false
+        if paired
+            return Rust::StatisticalTests::Wilcoxon.paired(d1, d2)
+        else
+            return Rust::StatisticalTests::Wilcoxon.unpaired(d1, d2)
+        end
+    end
+    
+    def t_test(d1, d2, **args)
+        paired = args[:paired] || false
+        if paired
+            return Rust::StatisticalTests::T.paired(d1, d2)
+        else
+            return Rust::StatisticalTests::T.unpaired(d1, d2)
+        end
+    end
+end

data/lib/rust.rb

@@ -0,0 +1,3 @@
+require_relative 'rust-tests'
+require_relative 'rust-effsize'
+require_relative 'rust-descriptive'

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: rust
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Simone Scalabrino
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rinruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: code-assertions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+description: Ruby advanced statistical library based on RinRuby
+email: s.scalabrino9@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rust-core.rb
+- lib/rust-descriptive.rb
+- lib/rust-effsize.rb
+- lib/rust-tests.rb
+- lib/rust.rb
+homepage: https://github.com/intersimone999/ruby-rust
+licenses:
+- GPL-3.0-only
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Ruby advanced statistical library
+test_files: []