rust 0.7 → 0.11

data/lib/{rust-tests.rb → rust/stats/tests.rb}

@@ -1,6 +1,13 @@
-require_relative 'rust-core'
+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
@@ -21,16 +28,28 @@ module Rust::StatisticalTests
             @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 1 unless @hypothesis
+            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
@@ -43,7 +62,13 @@ module Rust::StatisticalTests
         end
     end
     
-    class Hypothesis        
+    ##
+    # 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
             
@@ -63,18 +88,28 @@ module Rust::StatisticalTests
         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
         
-        def adjusted_pvalue_for(instance, method)
+        ##
+        # 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(instance)
+            index = @results.index(result)
             
             adjusted_pvalues = Rust::StatisticalTests::PValueAdjustment.method(method).adjust(*p_values)
             
@@ -85,85 +120,17 @@ module Rust::StatisticalTests
             end
         end
     end
-end
-
-module Rust::StatisticalTests::PValueAdjustment
-    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
-    
-    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
     
-    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
-    
-    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
-    
-    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
-    
-    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
-    
-    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
+    ##
+    # Class with utilities for running Wilcoxon Signed-Rank test and Ranked-Sum test (a.k.a. Mann-Whitney U test).
 
-module Rust::StatisticalTests::Wilcoxon
-    class << self
-         def paired(d1, d2, alpha = 0.05, **options)
+    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
@@ -185,7 +152,11 @@ module Rust::StatisticalTests::Wilcoxon
             end
         end
         
-        def unpaired(d1, d2, alpha = 0.05, **options)
+        ##
+        # 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) }
             
@@ -206,11 +177,17 @@ module Rust::StatisticalTests::Wilcoxon
             end
         end
     end
-end
+
+    ##
+    # Class with utilities for running the T test.
     
-module Rust::StatisticalTests::T
-    class << self
-        def paired(d1, d2, alpha = 0.05, **options)
+    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
@@ -232,7 +209,11 @@ module Rust::StatisticalTests::T
             end
         end
         
-        def unpaired(d1, d2, alpha = 0.05, **options)
+        ##
+        # 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) }
             
@@ -253,11 +234,17 @@ module Rust::StatisticalTests::T
             end
         end
     end
-end
 
-module Rust::StatisticalTests::Shapiro
-    class << self
-        def compute(vector, alpha = 0.05, **options)
+    ##
+    # 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
@@ -275,6 +262,105 @@ module Rust::StatisticalTests::Shapiro
             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

data/lib/rust.rb

@@ -1,9 +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-probabilities'
+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.7'
+  version: '0.11'
 platform: ruby
 authors:
 - Simone Scalabrino
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-16 00:00:00.000000000 Z
+date: 2022-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rinruby
@@ -52,20 +52,39 @@ 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-probabilities.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/external/robustbase.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
@@ -85,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.7
+rubygems_version: 3.3.15
 signing_key:
 specification_version: 4
 summary: Ruby advanced statistical library

data/lib/rust-calls.rb

@@ -1,80 +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 SimpleFormula
-        def initialize(dependent, independent)
-            @dependent = dependent
-            @independent = independent
-        end
-        
-        def to_R
-            return "#@dependent ~ #@independent"
-        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