rust 0.12 → 0.15

data/lib/rust/models/regression.rb

@@ -14,6 +14,11 @@ module Rust::Models::Regression
     # Generic regression model in R.
     
     class RegressionModel < Rust::RustDatatype
+        
+        attr_accessor :data
+        attr_accessor :dependent_variable
+        attr_accessor :options
+        
         def self.can_pull?(type, klass)
             # Can only pull specific sub-types
             return false
@@ -38,22 +43,30 @@ module Rust::Models::Regression
             
             formula = Rust::Formula.new(dependent_variable, independent_variables.join(" + "))
             
+            result = nil
             Rust.exclusive do
                 Rust["#{model_type}.data"] = data
                 
                 Rust._eval("#{model_type}.model.result <- #{model_type}(#{formula.to_R}, data=#{model_type}.data#{mapped})")
                 result = Rust["#{model_type}.model.result"]
-                result.r_mirror_to("#{model_type}.model.result")
                 
-                return result
+                raise "An error occurred while building the model" unless result
+                
+                result.r_mirror_to("#{model_type}.model.result")
             end
+            
+            result.dependent_variable = dependent_variable
+            result.data = data
+            result.options = options
+            
+            return result
         end
         
         ##
-        # Creates a new +model+.
+        # Creates a new model based on +model+.
             
         def initialize(model)
-            raise StandardError if model.is_a?(RegressionModel)
+            raise "Expected a R list, given a #{model.class}" if !model.is_a?(Rust::List)
             @model = model
         end
         
@@ -118,10 +131,72 @@ module Rust::Models::Regression
             a = self.summary|"coefficients"
         end
         
+        ##
+        # Returns object variables for the model with basic data (coefficients and p-values). Use the method `coefficients`
+        # to get more data.
+        
+        def variables
+            unless @variables
+                coefficients = self.coefficients
+                
+                @variables = coefficients.rownames.map do |name|
+                    ModelVariable.new(name, coefficients[name, "Estimate"], coefficients[name, "Pr(>|t|)"])
+                end
+            end
+            
+            return @variables
+        end
+        
+        ##
+        # Returns only the significant variables as ModelVariable instances. See the method `variables`.
+        
+        def significant_variables(a = 0.05)
+            self.variables.select { |v| v.significant?(a) }
+        end
+        
+        ##
+        # Runs backward selection (recursively removes a variable until the best model is found).
+        # Returns both the best model and the list of excluded variable at each step
+        # Note: Not fully tested
+        
+        def backward_selection(excluded = [])
+            candidates = self.variables.select { |v| !v.intercept? && !v.significant? }.sort_by { |v| v.pvalue }.reverse
+            all = self.variables.select { |v| !v.intercept? }
+            
+            candidates.each do |candidate|
+                new_model = RegressionModel.generate(
+                    self.class,
+                    self.class.r_model_name,
+                    self.dependent_variable,
+                    (all - [candidate]).map { |v| v.name },
+                    self.data,
+                    **self.options
+                )
+                
+                if new_model.r_2_adjusted >= self.r_2_adjusted
+                    puts "Excluded #{candidate}" if Rust.debug?
+                    return *new_model.backward_selection(excluded + [candidate])
+                end
+            end
+            
+            return self, excluded
+        end
+
+        ##
+        # Predicts the dependent variable from a new observation of the independent ones.
+        # Note: Not fully tested
+
+        def predict(line)
+            Rust.exclusive do
+                Rust['tmp.model.newline'] = line
+                return Rust["predict(#{self.r_mirror}, tmp.model.newline)"]
+            end
+        end
+        
         def method_missing(name, *args)
             return model|name.to_s
         end
-        
+
         ##
         # Returns a summary for the model using the summary function in R.
         
@@ -145,7 +220,11 @@ module Rust::Models::Regression
     
     class LinearRegressionModel < RegressionModel
         def self.can_pull?(type, klass)
-            return type == "list" && klass == "lm"
+            return type == "list" && klass == self.r_model_name
+        end
+        
+        def self.pull_priority
+            1
         end
         
         def self.pull_variable(variable, type, klass)
@@ -154,6 +233,10 @@ module Rust::Models::Regression
             return LinearRegressionModel.new(model)
         end
         
+        def self.r_model_name
+            "lm"
+        end
+        
         ##
         # Generates a linear regression model, given its +dependent_variable+ and +independent_variables+ and its +data+. 
         # +options+ can be specified and directly passed to the model. 
@@ -161,13 +244,64 @@ module Rust::Models::Regression
         def self.generate(dependent_variable, independent_variables, data, **options)
             RegressionModel.generate(
                 LinearRegressionModel,
-                "lm", 
+                self.r_model_name, 
                 dependent_variable, 
                 independent_variables, 
                 data, 
                 **options
             )
         end
+
+        ##
+        # Returns the model as a proc that can be used to predict values
+
+        def to_proc
+            proc do |unnormalized_data|
+                data = Rust::DataFrame.new(["__TOREM__"])
+                unnormalized_data.rows.times do
+                    data << [0]
+                end
+                unnormalized_data.colnames.each do |col|
+                    if (unnormalized_data|col)[0].is_a?(Numeric)
+                        newcol = Rust::DataFrame.new([col])
+                        (unnormalized_data|col).each do |v|
+                            newcol << [v]
+                        end
+                        data.cbind!(newcol)
+                    else
+                        (unnormalized_data|col).uniq.each do |val|
+                            newcol = Rust::DataFrame.new([col + val])
+                            (unnormalized_data|col).each do |v|
+                                if v == val
+                                    newcol << [1]
+                                else
+                                    newcol << [0]
+                                end
+                            end
+                            data.cbind!(newcol)
+                        end
+                    end
+                end
+                data.delete_column("__TOREM__")
+                value = 0
+                @variables.each do |var|
+                    p var
+                    if var.name == "(Intercept)"
+                        value += var.coefficient
+                    else
+                        if data.colnames.include?(var.name)
+                            value += (data|var.name)[0] * var.coefficient
+                        end
+                    end
+                end
+
+                value
+            end
+        end
+
+        def predict(line)
+            self.to_proc.call(line)
+        end
     end
     
     ##
@@ -175,13 +309,17 @@ module Rust::Models::Regression
     
     class LinearMixedEffectsModel < RegressionModel
         def self.can_pull?(type, klass)
-            return type == "S4" && klass == "lmerModLmerTest"
+            return type == "S4" && klass == self.r_model_name
         end
         
         def self.pull_priority
             1
         end
         
+        def self.r_model_name
+            "lmerModLmerTest"
+        end
+        
         def self.pull_variable(variable, type, klass)
             model = Rust::RustDatatype.pull_variable(variable, Rust::S4Class)
             
@@ -213,7 +351,7 @@ module Rust::Models::Regression
             
             RegressionModel.generate(
                 LinearMixedEffectsModel,
-                "lmer", 
+                self.r_model_name, 
                 dependent_variable, 
                 fixed_effects + random_effects, 
                 data, 
@@ -235,18 +373,44 @@ module Rust::Models::Regression
             end
         end
     end
+    
+    ##
+    # Slim representation for a variable in a model, with just the variable name, its coefficient and its p-value.
+    
+    class ModelVariable
+        attr_accessor   :name
+        attr_accessor   :coefficient
+        attr_accessor   :pvalue
+        
+        def initialize(name, coefficient, pvalue)
+            @name = name
+            @coefficient = coefficient
+            @pvalue = pvalue
+        end
+        
+        def intercept?
+            @name == "(Intercept)"
+        end
+        
+        ##
+        # Checks whether the variable is significant w.r.t. a given +a+ (0.05 by default)
+        
+        def significant?(a = 0.05)
+            @pvalue <= a
+        end
+    end
 end
 
 module Rust::RBindings
     def lm(formula, data, **options)
         independent = formula.right_part.split("+").map { |v| v.strip }
-        return LinearRegressionModel.generate(formula.left_part, independent, data, **options)
+        return Rust::Models::Regression::LinearRegressionModel.generate(formula.left_part, independent, data, **options)
     end
     
     def lmer(formula, data, **options)
         independent = formula.right_part.split("+").map { |v| v.strip }
         
-        RegressionModel.generate(
+        Rust::Models::Regression::RegressionModel.generate(
             LinearMixedEffectsModel,
             "lmer", 
             formula.left_part, 

data/lib/rust/stats/probabilities.rb

@@ -85,6 +85,20 @@ module Rust
             @values.map { |k, v| k*v }.sum
         end
         
+        ##
+        # Returns the variance for this slice.
+        
+        def variance
+            @values.map { |k, v| k**2 * v }.sum - (self.expected ** 2)
+        end
+        
+        ##
+        # Returns the standard deviation for this slice.
+        
+        def sd
+            Math.sqrt(self.variance)
+        end
+        
         ##
         # Returns a slice with the values that are greater than +n+.
         
@@ -124,7 +138,7 @@ module Rust
         # Returns a slice with the values between +a+ and +b+.
         
         def between(a, b)
-            self.so_that { |k| k.between(a, b) }
+            self.so_that { |k| k.between?(a, b) }
         end
         
         ##
@@ -133,6 +147,13 @@ module Rust
         def so_that
             RandomVariableSlice.new(@values.select { |k, v| yield(k) })
         end
+        
+        ##
+        # Creates a bar plot of the distribution
+        
+        def plot
+            Rust::Plots::BarPlot.new(@values.sort_by { |k, v| k }.to_h)
+        end
     end
     
     ##

data/lib/rust.rb

@@ -2,6 +2,7 @@ require_relative 'rust/core'
 require_relative 'rust/models/all'
 require_relative 'rust/plots/all'
 require_relative 'rust/stats/all'
+require_relative 'rust/forms/all'
 
 module Rust
     @@datasets = {}

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rust
 version: !ruby/object:Gem::Version
-  version: '0.12'
+  version: '0.15'
 platform: ruby
 authors:
 - Simone Scalabrino
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-17 00:00:00.000000000 Z
+date: 2026-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rinruby
@@ -61,6 +60,7 @@ files:
 - lib/rust.rb
 - lib/rust/core.rb
 - lib/rust/core/csv.rb
+- lib/rust/core/manual.rb
 - lib/rust/core/rust.rb
 - lib/rust/core/types/all.rb
 - lib/rust/core/types/dataframe.rb
@@ -74,10 +74,14 @@ files:
 - lib/rust/external/ggplot2.rb
 - lib/rust/external/ggplot2/core.rb
 - lib/rust/external/ggplot2/geoms.rb
-- lib/rust/external/ggplot2/helper.rb
 - lib/rust/external/ggplot2/plot_builder.rb
+- lib/rust/external/ggplot2/scale.rb
 - lib/rust/external/ggplot2/themes.rb
 - lib/rust/external/robustbase.rb
+- lib/rust/forms/all.rb
+- lib/rust/forms/google_forms.rb
+- lib/rust/jobs/all.rb
+- lib/rust/jobs/jobs.rb
 - lib/rust/models/all.rb
 - lib/rust/models/anova.rb
 - lib/rust/models/regression.rb
@@ -95,7 +99,6 @@ homepage: https://github.com/intersimone999/ruby-rust
 licenses:
 - GPL-3.0-only
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -110,8 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.15
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby advanced statistical library
 test_files: []

data/lib/rust/external/ggplot2/helper.rb

@@ -1,122 +0,0 @@
-require_relative 'core'
-
-GGPLOT_EXAMPLES = {}
-
-GGPLOT_EXAMPLES[["Quick introduction", /intro/]] = <<-EOS
-bind_ggplot! # Avoid using long module names to reach Rust::Plots::GGPlot (simply includes this module)
-
-# Best with a dataframe, but not necessary. If you have it...
-df = Rust.toothgrowth
-plot = PlotBuilder.for_dataframe(df). # Use a dataframe (symbols will be variable names)
-        labeled("Example plot"). # "labeled" sets the label to the last set aesthetic item (x, y, or title, in this case)
-        with_x(:len).labeled("X data from df").  # Set all the aesthetics (x, y, ...)
-        with_y(:dose).labeled("Y data from df").
-        draw_points. # Set the geometries to plot (based on the plot type)
-        build # Returns the plot ready to use
-plot.show # Show the plot in a window
-plot.save("output.pdf", width: 5, height: 4) # Save the plot, width, height etc. are optional
-
-# If you don't have a dataframe...
-plot2 = PlotBuilder.new.
-        with_x([1,2,3]).labeled("X data from df").
-        with_y([3,4,5]).labeled("Y data from df").
-        draw_points.
-        build
-plot2.show
-EOS
-
-GGPLOT_EXAMPLES[["Scatter plots", /scatter/]] = <<-EOS
-bind_ggplot!
-df = Rust.toothgrowth
-plot = PlotBuilder.for_dataframe(df).
-        with_x(:len).labeled("X data").
-        with_y(:dose).labeled("Y data").
-        draw_points. # To draw points
-        draw_lines.  # To draw lines (keep both to draw both)
-        build
-plot.show
-EOS
-
-GGPLOT_EXAMPLES[["Bar plots", /bar/]] = <<-EOS
-bind_ggplot!
-df = Rust.toothgrowth
-plot = PlotBuilder.for_dataframe(df).
-        with_x(:len).labeled("X data").
-        with_fill(:supp).labeled("Legend"). # Use with_fill or with_color for stacked plots
-        draw_bars. # To draw bars
-        build
-plot.show
-EOS
-
-GGPLOT_EXAMPLES[["Box plots", /box/]] = <<-EOS
-bind_ggplot!
-df = Rust.toothgrowth
-plot = PlotBuilder.for_dataframe(df).
-        with_y(:len).labeled("Data to boxplot").
-        with_group(:supp).labeled("Groups"). # Groups to plot
-        draw_boxplot.
-        build
-plot.show
-EOS
-
-GGPLOT_EXAMPLES[["Histograms", /hist/]] = <<-EOS
-bind_ggplot!
-df = Rust.toothgrowth
-plot = PlotBuilder.for_dataframe(df).
-        with_x(:len).labeled("Data to plot").
-        with_fill(:supp).labeled("Color"). # Use with_fill or with_color for multiple plots
-        draw_histogram.
-        build
-plot.show
-EOS
-
-GGPLOT_EXAMPLES[["Themes", /them/]] = <<-EOS
-bind_ggplot!
-df = Rust.toothgrowth
-# The method with_theme allows to change theme options. The method can be called
-# several times, each time the argument does not overwrite the previous options,
-# unless they are specified again (in that case, the last specified ones win).
-plot = PlotBuilder.for_dataframe(df).
-        with_x(:len).labeled("X data").
-        with_y(:dose).labeled("Y data").
-        draw_points.
-        with_theme(
-            ThemeBuilder.new('bw').
-                title(face: 'bold', size: 12). # Each method sets the property for the related element
-                legend do |legend| # Legend and other parts can be set like this
-                    legend.position(:left) # Puts the legend on the left
-                end.
-                axis do |axis| # Modifies the axes
-                    axis.line(Theme::BlankElement.new) # Hides the lines for the axes
-                    axis.text_x(size: 3) # X axis labels
-                end.
-                panel do |panel|
-                    panel.grid_major(colour: 'grey70', size: 0.2) # Sets the major ticks grid
-                    panel.grid_minor(Theme::BlankElement.new) # Hides the minor ticks grid
-                end.
-                build
-        ).build
-plot.show
-EOS
-
-module Rust::Plots::GGPlot
-    def self.help!(topic = nil)
-        unless topic
-            puts "Topics:"
-            GGPLOT_EXAMPLES.keys.each do |key, matcher|
-                puts "- #{key}"
-            end
-            puts "Call again specifying the topic of interest."
-        else
-            GGPLOT_EXAMPLES.each do |key, value|
-                if topic.match(key[1])
-                    puts "*** #{key[0]} ***"
-                    puts value
-                    return
-                end
-            end
-            
-            puts "Topic not found"
-        end
-    end
-end