rust 0.4 → 0.10

data/lib/rust/stats/tests.rb

@@ -0,0 +1,384 @@
+require_relative '../core'
+
+##
+# Module with utilities for running statistical hypothesis tests.
+
+module Rust::StatisticalTests
+    
+    ##
+    # Represents the result of a statistical hypothesis test.
+    
+    class Result
+        attr_accessor   :name
+        attr_accessor   :statistics
+        attr_accessor   :pvalue
+        attr_accessor   :exact
+        attr_accessor   :alpha
+        attr_accessor   :hypothesis
+        
+        def initialize
+            @statistics = {}
+        end
+        
+        def [](name)
+            return @statistics[name.to_sym]
+        end
+        
+        def []=(name, value)
+            @statistics[name.to_sym] = value
+        end
+        
+        ##
+        # If a hypothesis is available, returns the adjusted p-value with respect to all the other results obtained for
+        # the same hypothesis. Otherwise, simply returns the p-value for this result.
+        # The +method+ for adjustment can be optionally specified (Bonferroni, by default).
+        
+        def adjusted_pvalue(method='bonferroni')
+            return @pvalue unless @hypothesis
+            @hypothesis.adjusted_pvalue_for(self, method)
+        end
+        
+        ##
+        # Sets the underlying hypothesis for the test. The p-values of the results belonging to the same hypothesis can
+        # be adjusted through the adjusted_pvalue method.
+        
+        def hypothesis=(value)
+            @hypothesis = value
+            @hypothesis.add(self)
+        end
+        
+        ##
+        # Returns true if the results are significant according to the specified alpha.
+        
+        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
+    
+    ##
+    # Represents a hypothesis behind one or more results.
+    
+    class Hypothesis
+        ##
+        # Returns the hypothesis with the given +title_or_instance+ as title (if String).
+        
+        def self.find(title_or_instance)
+            return Hypothesis.new(nil) if title_or_instance == nil
+            
+            if title_or_instance.is_a?(String)
+                ObjectSpace.each_object(Hypothesis) do |instance|
+                    return instance if instance.title == title_or_instance
+                end
+                
+                return Hypothesis.new(title_or_instance)
+            elsif title_or_instance.is_a?(Hypothesis)
+                return title_or_instance
+            end
+            
+            raise TypeError, "Expected nil, String or Hypothesis"
+        end
+        
+        attr_reader :results
+        attr_reader :title
+        
+        ##
+        # Creates a new hypothesis with a given +title+.
+        
+        def initialize(title)
+            @title = title
+            @results = []
+        end
+        
+        ##
+        # Registers a +result+ for this hypothesis.
+        
+        def add(result)            
+            @results << result
+        end
+        
+        ##
+        # Returns the adjusted p-value for a specific +result+ with respect to all the other results obtained under this
+        # same hypothesis, using the specified +method+.
+        
+        def adjusted_pvalue_for(result, method)
+            p_values = @results.map { |r| r.pvalue }
+            index = @results.index(result)
+            
+            adjusted_pvalues = Rust::StatisticalTests::PValueAdjustment.method(method).adjust(*p_values)
+            
+            if adjusted_pvalues.is_a?(Numeric)
+                return adjusted_pvalues
+            else
+                return adjusted_pvalues[index]
+            end
+        end
+    end
+    
+    ##
+    # Class with utilities for running Wilcoxon Signed-Rank test and Ranked-Sum test (a.k.a. Mann-Whitney U test).
+
+    class Wilcoxon
+        
+        ##
+        # Runs a Wilxoson Signed-Rank test for +d1+ and +d2+, with a given +alpha+ (0.05, by default). 
+        # +options+ can be specified and directly passed to the R function.
+        
+        def self.paired(d1, d2, alpha = 0.05, **options)
+            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["wilcox.a"] = d1
+                Rust["wilcox.b"] = d2
+                
+                _, warnings = Rust._eval("wilcox.result = wilcox.test(wilcox.a, wilcox.b, alternative='two.sided', paired=T)", true)
+                result = Rust::StatisticalTests::Result.new
+                result.name       = "Wilcoxon Signed-Rank test"
+                result.pvalue     = Rust._pull("wilcox.result$p.value")
+                result[:w]        = Rust._pull("wilcox.result$statistic")
+                result.exact      = !warnings.include?("cannot compute exact p-value with zeroes")
+                result.alpha      = alpha
+                result.hypothesis = Rust::StatisticalTests::Hypothesis.find(options[:hypothesis])
+            
+                return result
+            end
+        end
+        
+        ##
+        # Runs a Wilxoson Ranked-Sum (a.k.a. Mann-Whitney U) test for +d1+ and +d2+, with a given +alpha+ (0.05, by default). 
+        # +options+ can be specified and directly passed to the R function.
+        
+        def self.unpaired(d1, d2, alpha = 0.05, **options)
+            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["wilcox.a"] = d1
+                Rust["wilcox.b"] = d2
+                
+                _, warnings = Rust._eval("wilcox.result = wilcox.test(wilcox.a, wilcox.b, alternative='two.sided', paired=F)", true)
+                result = Rust::StatisticalTests::Result.new
+                result.name       = "Wilcoxon Ranked-Sum test (a.k.a. Mann–Whitney U test)"
+                result.pvalue     = Rust._pull("wilcox.result$p.value")
+                result[:w]        = Rust._pull("wilcox.result$statistic")
+                result.exact      = !warnings.include?("cannot compute exact p-value with ties")
+                result.alpha      = alpha
+                result.hypothesis = Rust::StatisticalTests::Hypothesis.find(options[:hypothesis])
+                
+                return result
+            end
+        end
+    end
+
+    ##
+    # Class with utilities for running the T test.
+    
+    class T
+        
+        ##
+        # Runs a paired T test for +d1+ and +d2+, with a given +alpha+ (0.05, by default). 
+        # +options+ can be specified and directly passed to the R function.
+        
+        def self.paired(d1, d2, alpha = 0.05, **options)
+            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["t.a"] = d1
+                Rust["t.b"] = d2
+                
+                warnings = Rust._eval("t.result = t.test(t.a, t.b, alternative='two.sided', paired=T)")
+                result = Rust::StatisticalTests::Result.new
+                result.name       = "Paired t-test"
+                result.pvalue     = Rust._pull("t.result$p.value")
+                result[:t]        = Rust._pull("t.result$statistic")
+                result.exact      = true
+                result.alpha      = alpha
+                result.hypothesis = Rust::StatisticalTests::Hypothesis.find(options[:hypothesis])
+                
+                return result
+            end
+        end
+        
+        ##
+        # Runs an unpaired T test for +d1+ and +d2+, with a given +alpha+ (0.05, by default). 
+        # +options+ can be specified and directly passed to the R function.
+        
+        def self.unpaired(d1, d2, alpha = 0.05, **options)
+            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["t.a"] = d1
+                Rust["t.b"] = d2
+                
+                Rust._eval("t.result = t.test(t.a, t.b, alternative='two.sided', paired=F)")
+                result = Rust::StatisticalTests::Result.new
+                result.name       = "Welch Two Sample t-test"
+                result.pvalue     = Rust._pull("t.result$p.value")
+                result[:t]        = Rust._pull("t.result$statistic")
+                result.exact      = true
+                result.alpha      = alpha
+                result.hypothesis = Rust::StatisticalTests::Hypothesis.find(options[:hypothesis])
+                
+                return result
+            end
+        end
+    end
+
+    ##
+    # Utilities for the Shapiro normality test.
+    
+    class Shapiro
+        
+        ##
+        # Runs the Shapiro normality test for +vector+ and a given +alpha+ (0.05, by default).
+        # +options+ can be specified and directly passed to the R function.
+        
+        def self.compute(vector, alpha = 0.05, **options)
+            raise TypeError, "Expecting Array of numerics" if !vector.is_a?(Array) || !vector.all? { |e| e.is_a?(Numeric) }
+            Rust.exclusive do
+                Rust['shapiro.v'] = vector
+                
+                Rust._eval("shapiro.result = shapiro.test(shapiro.v)")
+                result = Rust::StatisticalTests::Result.new
+                result.name       = "Shapiro-Wilk normality test"
+                result.pvalue     = Rust._pull("shapiro.result$p.value")
+                result[:W]        = Rust._pull("shapiro.result$statistic")
+                result.exact      = true
+                result.alpha      = alpha
+                result.hypothesis = Rust::StatisticalTests::Hypothesis.find(options[:hypothesis])
+                
+                return result
+            end
+        end
+    end
+    
+    ##
+    # Module with utilities for adjusting the p-values.
+    
+    module PValueAdjustment
+        
+        ##
+        # Returns the Ruby class given the R name of the p-value adjustment method.
+        
+        def self.method(name)
+            name = name.to_s
+            case name.downcase
+            when "bonferroni", "b"
+                return Bonferroni
+            when "holm", "h"
+                return Holm
+            when "hochberg"
+                return Hochberg
+            when "hommel"
+                return Hommel
+            when "benjaminihochberg", "bh"
+                return BenjaminiHochberg
+            when "benjaminiyekutieli", "by"
+                return BenjaminiYekutieli
+            end
+        end
+        
+        ##
+        # Bonferroni p-value adjustment method.
+        
+        class Bonferroni
+            def self.adjust(*p_values)
+                Rust.exclusive do
+                    Rust['adjustment.p'] = p_values
+                    return Rust._pull("p.adjust(adjustment.p, method=\"bonferroni\")")
+                end
+            end
+        end
+        
+        ##
+        # Holm p-value adjustment method.
+        
+        class Holm
+            def self.adjust(*p_values)
+                Rust.exclusive do
+                    Rust['adjustment.p'] = p_values
+                    return Rust._pull("p.adjust(adjustment.p, method=\"holm\")")
+                end
+            end
+        end
+        
+        ##
+        # Hochberg p-value adjustment method.
+        
+        class Hochberg
+            def self.adjust(*p_values)
+                Rust.exclusive do
+                    Rust['adjustment.p'] = p_values
+                    return Rust._pull("p.adjust(adjustment.p, method=\"hochberg\")")
+                end
+            end
+        end
+        
+        ##
+        # Hommel p-value adjustment method.
+        
+        class Hommel
+            def self.adjust(*p_values)
+                Rust.exclusive do
+                    Rust['adjustment.p'] = p_values
+                    return Rust._pull("p.adjust(adjustment.p, method=\"hommel\")")
+                end
+            end
+        end
+        
+        ##
+        # Benjamini-Hochberg p-value adjustment method.
+        
+        class BenjaminiHochberg
+            def self.adjust(*p_values)
+                Rust.exclusive do
+                    Rust['adjustment.p'] = p_values
+                    return Rust._pull("p.adjust(adjustment.p, method=\"BH\")")
+                end
+            end
+        end
+        
+        ##
+        # Benjamini-Yekutieli p-value adjustment method.
+        
+        class BenjaminiYekutieli
+            def self.adjust(*p_values)
+                Rust.exclusive do
+                    Rust['adjustment.p'] = p_values
+                    return Rust._pull("p.adjust(adjustment.p, method=\"BY\")")
+                end
+            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

@@ -1,8 +1,4 @@
-require_relative 'rust-core'
-require_relative 'rust-basics'
-require_relative 'rust-csv'
-require_relative 'rust-tests'
-require_relative 'rust-effsize'
-require_relative 'rust-descriptive'
-require_relative 'rust-plots'
-require_relative 'rust-calls'
+require_relative 'rust/core'
+require_relative 'rust/models/all'
+require_relative 'rust/plots/all'
+require_relative 'rust/stats/all'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rust
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.10'
 platform: ruby
 authors:
 - Simone Scalabrino
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-15 00:00:00.000000000 Z
+date: 2022-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rinruby
@@ -52,19 +52,38 @@ dependencies:
         version: 1.1.2
 description: Ruby advanced statistical library based on RinRuby
 email: s.scalabrino9@gmail.com
-executables: []
+executables:
+- ruby-rust
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/rust-basics.rb
-- lib/rust-calls.rb
-- lib/rust-core.rb
-- lib/rust-csv.rb
-- lib/rust-descriptive.rb
-- lib/rust-effsize.rb
-- lib/rust-plots.rb
-- lib/rust-tests.rb
+- bin/ruby-rust
 - lib/rust.rb
+- lib/rust/core.rb
+- lib/rust/core/csv.rb
+- lib/rust/core/rust.rb
+- lib/rust/core/types/all.rb
+- lib/rust/core/types/dataframe.rb
+- lib/rust/core/types/datatype.rb
+- lib/rust/core/types/factor.rb
+- lib/rust/core/types/language.rb
+- lib/rust/core/types/list.rb
+- lib/rust/core/types/matrix.rb
+- lib/rust/core/types/s4class.rb
+- lib/rust/core/types/utils.rb
+- lib/rust/models/all.rb
+- lib/rust/models/anova.rb
+- lib/rust/models/regression.rb
+- lib/rust/plots/all.rb
+- lib/rust/plots/basic-plots.rb
+- lib/rust/plots/core.rb
+- lib/rust/plots/distribution-plots.rb
+- lib/rust/stats/all.rb
+- lib/rust/stats/correlation.rb
+- lib/rust/stats/descriptive.rb
+- lib/rust/stats/effsize.rb
+- lib/rust/stats/probabilities.rb
+- lib/rust/stats/tests.rb
 homepage: https://github.com/intersimone999/ruby-rust
 licenses:
 - GPL-3.0-only
@@ -84,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.15
 signing_key:
 specification_version: 4
 summary: Ruby advanced statistical library

data/lib/rust-calls.rb

@@ -1,69 +0,0 @@
-require_relative 'rust-core'
-
-module Rust
-    class Function
-        attr_reader     :name
-        attr_reader     :arguments
-        attr_reader     :options
-        
-        def initialize(name)
-            @function = name
-            @arguments  = Arguments.new
-            @options    = Options.new
-        end
-        
-        def options=(options)
-            raise TypeError, "Expected Options" unless options.is_a?(Options)
-            
-            @options = options
-        end
-        
-        def arguments=(arguments)
-            raise TypeError, "Expected Arguments" unless options.is_a?(Arguments)
-            
-            @arguments = arguments
-        end
-        
-        def to_R
-            params = [@arguments.to_R, @options.to_R].select { |v| v != "" }.join(",")
-            return "#@function(#{params})"
-        end
-        
-        def call
-            Rust._eval(self.to_R)
-        end
-    end
-    
-    class Variable
-        def initialize(name)
-            @name = name
-        end
-        
-        def to_R
-            @name
-        end
-    end
-    
-    class Arguments < Array
-        def to_R
-            return self.map { |v| v.to_R }.join(", ")
-        end
-    end
-    
-    class Options < Hash
-        def to_R
-            return self.map { |k, v| "#{k}=#{v.to_R}" }.join(", ")
-        end
-        
-        def self.from_hash(hash)
-            options = Options.new
-            hash.each do |key, value|
-                options[key.to_s] = value
-            end
-            return options
-        end
-    end
-end
-
-module Rust::RBindings
-end

data/lib/rust-descriptive.rb

@@ -1,67 +0,0 @@
-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) }
-            
-            return Math.sqrt(variance(data))
-        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) }
-            return Float::NAN if data.size < 2
-            
-            mean = mean(data)
-            return data.map { |v| (v - mean) ** 2 }.sum.to_f / (data.size - 1)
-        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 sum(data)
-            raise TypeError, "Expecting Array of numerics" if !data.is_a?(Array) || !data.all? { |e| e.is_a?(Numeric) }
-            
-            return data.sum
-        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['descriptive.data'] = data
-                Rust['descriptive.percs'] = percentiles
-                
-                call_result = Rust._pull("quantile(descriptive.data, descriptive.percs)")
-                assert { call_result.is_a?(Array) }
-                assert { call_result.size == percentiles.size }
-                
-                return percentiles.zip(call_result).to_h
-            end
-        end
-    end
-end