rust 0.13 → 0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56e795fb0a8893df45abd976e2ed91344156f3c3dd4a68e17afd1a0fb317ece3
-  data.tar.gz: 406416738f1ab84fca06edd5cb59efdc623b12cefe03cd51b1a2cd840e218647
+  metadata.gz: aef18d4ed8bce09d5931fa0e9fde630ff36e1436897a448bbbc1dd2b451a28fc
+  data.tar.gz: 9313ac648a27c9f1cb6b369ba43852e0defb4bd4ab0a089b1c58ad4e43322de5
 SHA512:
-  metadata.gz: 56854c3ff1bbd64ca8ff9d1201bc16fd37f4d3d465527217ab5c49d5cee0d6f4f34998bdf8a3ebdedf7ea8379909ca0db75d05da1bd46460c3e7066ee882ba7b
-  data.tar.gz: 6b21ba70c7d144384d1647dfa76f8894457bf4d65b74ce32d4e775cc3ecdc660f4596f61edd81e91b08c9d2b3def3491cebe10b7923b9f2988d072f7c5d25674
+  metadata.gz: 9908bd416aa81bbd07ad8b5f4960481c31e9ed8da2b106e3e129b4165d835343029b43ee0cd1b74b1fd56451039a5558abda553037c4887ebf6f9b5865dc5202
+  data.tar.gz: db41177a2182dc57516459bbfff5ee6d361c275ccd1d78b5a5b2767da433a5cde366303b598d4e9bd00d692c14c682044bbc4976392973415099573185fcee15

data/lib/rust/core/types/dataframe.rb

@@ -607,6 +607,8 @@ module Rust
         # Sorts the rows of this data-frame by the values of the +by+ column.
         
         def sort_by!(by)
+            raise TypeError, "String expected" unless by.is_a?(String)
+            raise "'#{by}' is not a valid column name (#{self.colnames.to_s})" unless self.colnames.include?(by)
             copy = @data[by].clone
             copy.sort!
             

data/lib/rust/core/types/datatype.rb

@@ -109,13 +109,23 @@ module Rust
     
     class Null < RustDatatype
         def self.can_pull?(type, klass)
-            return type == "NULL" && klass == "NULL"
+            return (type == "NULL" && klass == "NULL")
         end
         
         def self.pull_variable(variable, type, klass)
             return nil
         end
     end
+
+    class Omit < RustDatatype
+        def self.can_pull?(type, klass)
+            return (klass == "omit")
+        end
+
+        def self.pull_variable(variable, type, klass)
+            return Rust["as.#{type}(#{variable})"]
+        end
+    end
 end
 
 class TrueClass

data/lib/rust/forms/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

data/lib/rust/forms/google_forms.rb

@@ -0,0 +1,283 @@
+require_relative '../core'
+require 'time'
+
+module Rust
+    
+    ##
+    # Class that allows to read CSVs exported from Google Forms.
+    class GoogleFormMapping
+
+        ##
+        # Loads a mapping from a CSV file that can be used in the constructor of GoogleForm given the CSV +filename+ and the
+        # keys for defining what should be transformed (+key_from+) in what (+key_to+). Returns a hash with the mapping
+        # from -> to.
+
+        def self.load(filename, key_from="from", key_to="to", **options)
+            raise TypeError, "Expected string for filename" unless filename.is_a?(String)
+            raise TypeError, "Expected string for key_from" unless key_from.is_a?(String)
+            raise TypeError, "Expected string for key_to" unless key_to.is_a?(String)
+
+            result = {}
+            mapping = Rust::CSV.read(filename, headers: true)
+            mapping.each do |r|
+                result[r[key_from]] = r[key_to]
+            end
+
+            return GoogleFormMapping.new(result, **options)
+        end
+
+        def initialize(hash, **options)
+            raise TypeError, "Hash should be an hash" unless hash.is_a?(Hash)
+            raise TypeError, "Mapping for question #{question} must have either all String keys or all Regexp keys." if !hash.keys.all? { |m| m.is_a?(Regexp) } && !hash.keys.all? { |m| m.is_a?(String) }
+            raise "Unsupported options: #{options.keys - [:strip, :downcase]}" if (options.keys - [:strip, :downcase]).size > 0
+
+            if hash.keys.all? { |m| m.is_a?(Regexp) }
+                @type = :regexp
+            else
+                @type = :direct
+            end
+
+            @strip = options[:strip]
+            @downcase = options[:downcase]
+
+            if @type == :direct
+                @hash = {}
+                hash.each do |k, v|
+                    @hash[normalize(k)] = v
+                end
+            else
+                @hash = hash
+            end
+        end
+
+        def get(from)
+            if @type == :regexp
+                @hash.each do |k, v|
+                    if from.match(k)
+                        return v
+                    end
+                end
+                return from
+            elsif @type == :direct
+                return @hash[normalize(from)] || from
+            end
+        end
+
+        private
+        def normalize(string)
+            string = string.downcase if @downcase
+            string = string.strip    if @strip
+            return string
+        end
+    end
+    
+    class GoogleForm
+        ALLOWED_TYPES = [:multiple, :checkbox, :scale, :text]
+
+        ##
+        # Reads the CSV at +filename+ and returns a GoogleForm. The schema must be a hash that contains, for each question number or name,
+        # the type of answer (:multiple, :checkbox, :scale, or :text). For the other options, see Rust::CSV.read.
+        
+        def self.read(filename, schema, mappings={}, **options)
+            data_frame = Rust::CSV.read(filename, **options)
+
+            return GoogleForm.new(data_frame, schema, mappings)
+        end
+        
+        def initialize(data_frame, schema, mappings={})
+            raise TypeError, "Expected Rust::DataFrame" unless data_frame.is_a?(Rust::DataFrame)
+            raise TypeError, "Expected Hash or Array" if !schema.is_a?(Hash) && !schema.is_a?(Array)
+            raise TypeError, "Schema keys must all be numbers or strings" if schema.is_a?(Hash) && !schema.keys.all? { |k| k.is_a?(String) }
+            raise TypeError, "Mappings should be an hash [String, Integer] -> GoogleFormMapping" if !mappings.is_a?(Hash) || !mappings.keys.all? { |k| k.is_a?(String) || k.is_a?(Integer) } || !mappings.values.all? { |v| v.is_a?(GoogleFormMapping) }
+            if schema.is_a?(Array)
+                new_schema = {}
+                for i in 0...schema.size
+                    new_schema[index_to_title(i+1, data_frame)] = schema[i]
+                end
+                schema = new_schema
+            end
+            raise TypeError, "Schema values must all be #{ALLOWED_TYPES}; #{schema.values.uniq - ALLOWED_TYPES} given instead" if !schema.values.all? { |v| ALLOWED_TYPES.include?(v)}
+            raise TypeError, "Schema must include types for all the questions" if schema.size != (data_frame.columns - 1)
+
+            @data_frame = data_frame
+            @questions  = data_frame.colnames
+            @schema = schema
+
+            mappings.each do |question, mapping|
+                raise "Mappings can not be defined for :scale questions" if schema[title_to_index(question)] == :scale
+            end
+            @mappings = mappings
+        end
+
+        def data_frame
+            @data_frame
+        end
+
+        def mapped_data_frame
+            df = Rust::DataFrame.new(@data_frame.colnames)
+            self.each_answer do |a|
+                df << a
+            end
+            return df
+        end
+
+        def rows
+            @data_frame.rows
+        end
+
+        def answer(i)
+            row = @data_frame.row(i)
+
+            @questions.each_with_index do |colname, i|
+                if i == 0
+                    row[colname] = Time.parse(row[colname])
+                else
+                    row[colname] = get_value(row[colname], colname)
+                end
+            end
+
+            return row
+        end
+
+        def each_answer
+            for i in 0...@data_frame.rows
+                yield(self.answer(i))
+            end
+        end
+
+        def answers
+            answers = []
+            for i in 0...@data_frame.rows
+                answers << self.answer(i)
+            end
+            return answers
+        end
+
+        def filter
+            matching = Rust::DataFrame.new(@questions)
+
+            for i in 0...@data_frame.rows
+                matching << @data_frame.row(i) if yield(self.answer(i))
+            end
+
+            return GoogleForm.new(matching, @schema, @mappings)
+        end
+
+        def raw_answers_to(question)
+            question = index_to_title(question) if question.is_a?(Integer)
+            results = []
+
+            (@data_frame|question).each do |value|
+                value = get_value(value, question)
+                results << value
+            end
+
+            return results
+        end
+
+        def answers_to(question)
+            question = index_to_title(question) if question.is_a?(Integer)
+
+            results = {}
+
+            (@data_frame|question).each do |value|
+                value = get_value(value, question)
+                if value.is_a?(Array)
+                    value.each do |v|
+                        results[v] = 0 unless results[v]
+                        results[v] += 1
+                    end
+                else
+                    results[value] = 0 unless results[value]
+                    results[value] += 1
+                end
+            end
+            results.delete(nil)
+
+            return results
+        end
+
+        def textual_answers_to(question)
+            question = index_to_title(question) if question.is_a?(Integer)
+            raise TypeError, "Expected textual question, #{@schema[question]} instead" if @schema[question] != :text
+
+            results = {}
+
+            (@data_frame|question).each do |value|
+                value = get_value(value, question)
+                next if value == nil
+
+                category = yield(value)
+                results[category] = 0 unless results[category]
+                results[category] += 1
+            end
+
+            return results
+        end
+
+        def percentual_answers_to(question, exclude=[])
+            answers = answers_to(question)
+
+            exclude.each do |ex|
+                answers.delete(ex)
+            end
+
+            tot = answers.values.sum
+            answers = answers.map { |k, v| [k, v.to_f/tot] }.to_h
+            return answers
+        end
+
+        def percentual_textual_answers_to(question, &block)
+            answers = textual_answers_to(question, &block)
+
+            tot = answers.values.sum
+            answers = answers.map { |k, v| [k, v.to_f/tot] }.to_h
+            return answers
+        end
+
+        private
+        def index_to_title(i, data_frame=@data_frame)
+            data_frame.colnames[i]
+        end
+
+        def title_to_index(title, data_frame=@data_frame)
+            data_frame.colnames.index(title)
+        end
+
+        def get_value(value, question, data_frame=@data_frame)
+            mapping = @mappings[question]
+
+            mapped_value = mapping ? mapping.get(value) : value
+
+            case @schema[question]
+            when :multiple
+                return nil if mapped_value == ""
+                return mapped_value
+
+            when :checkbox
+                return value.split(';').map { |single_value| mapping ? mapping.get(single_value) : single_value }
+
+            when :scale
+                return nil if value == ""
+                ordinal = (data_frame|question).uniq.sort
+                ordinal.delete("")
+                return ordinal.index(value) + 1
+
+            when :text
+                return mapped_value
+            end
+
+            raise TypeError
+        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/jobs/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

data/lib/rust/jobs/jobs.rb

@@ -0,0 +1,144 @@
+require_relative '../core'
+
+module Rust::Jobs
+    class TaskHook
+        def initialize(task, on_complete, on_error)
+            @task = task
+            @on_complete = on_complete
+            @on_error = on_error
+        end
+
+        def complete!
+            @on_complete.call
+            @task.notify
+        end
+
+        def error!
+            @on_error.call
+            @task.notify
+        end
+    end
+
+    class Task
+        def initialize(title, &block)
+            raise "Expected block to describe the task" unless block_given?
+            @title = title
+            @todo  = block
+            @done  = false
+
+            @complete_hook = proc {}
+            @error_hook = proc {}
+        end
+
+        def start
+            @thread = Thread.start do
+                @todo.call(TaskHook.new(@complete_hook, @error_hook))
+            end
+        end
+
+        def notify
+            @done = true
+        end
+
+        def waitfor(granularity=0.1)
+            while !@done
+                sleep granularity
+            end
+        end
+
+        def commit
+        end
+
+        def on_complete(&block)
+            raise "Block expected" unless block_given?
+            @complete_hook = block
+        end
+
+        def on_error(&block)
+            raise "Block expected" unless block_given?
+            @error_hook = block
+        end
+    end
+
+    class Job
+        def initialize(name, **options)
+            @name = name
+            @tasks = []
+
+            @parallel = false
+
+            if options['parallel']
+                @parallel = true
+                @parallel_tasks = 10
+            end
+
+            if options['parallel_tasks'].is_a?(Integer)
+                @parallel_tasks = options['parallel_tasks'].to_i
+            end
+
+            @logger = options['logger'] ? options['logger'] : STDOUT
+
+            if options[:quiet]
+                @logger = File.open(File::NULL, "w")
+            end
+        end
+
+        def log(message, type="INFO")
+            @logger << "[#{type}] #{Time.now}: #{message.gsub("\n", " -- ")}"
+        end
+
+        def log_info(message)
+            log(message, "INFO")
+        end
+
+        def log_warning(message)
+            log(message, "WARNING")
+        end
+
+        def log_error(message)
+            log(message, "ERROR")
+        end
+
+        def add_task(task=nil, **options, &block)
+            if block_given?
+                raise "You gave both a block and a task. Please, choose one" if task
+                task = Task.new(options['title'], block)
+            end
+
+            raise "Expected a task, #{task.class} given instead" unless task.is_a?(Task)
+
+            @tasks << task
+        end
+
+        def start
+            log_info "Job \"#@name\" started"
+            if @parallel
+            else
+                @tasks.each do |t|
+                    t.on_complete do
+                        log_info "Task \"#{t.title}\" completed"
+                    end
+
+                    t.on_error do |message|
+                        log_error "Task \"#{t.title}\" did not complete: #{message}"
+                    end
+
+                    log_info "Task \"#{t.title}\" started"
+                    t.start
+                    t.waitfor
+                end
+            end
+        end
+    end
+
+    class Resumeable < Job
+        def initialize(name, **options)
+            super
+            # TODO complete here
+        end
+
+        def start
+            # TODO complete here
+        end
+    end
+end

data/lib/rust/models/regression.rb

@@ -181,12 +181,22 @@ module Rust::Models::Regression
             
             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.
         
@@ -241,6 +251,57 @@ module Rust::Models::Regression
                 **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
     
     ##

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.13'
+  version: '0.15'
 platform: ruby
 authors:
 - Simone Scalabrino
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-17 00:00:00.000000000 Z
+date: 2026-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rinruby
@@ -79,6 +78,10 @@ files:
 - 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
@@ -96,7 +99,6 @@ homepage: https://github.com/intersimone999/ruby-rust
 licenses:
 - GPL-3.0-only
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -111,8 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby advanced statistical library
 test_files: []