sapor 0.3.4

data/lib/sapor/dichotomy.rb

@@ -0,0 +1,164 @@
+# encoding: utf-8
+#
+# Statistical Analysis of Polling Results (SAPoR)
+# Copyright (C) 2016 Filip van Laenen <f.a.vanlaenen@ieee.org>
+#
+# This file is part of SAPoR.
+#
+# SAPoR is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# SAPoR is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You can find a copy of the GNU General Public License in /doc/gpl.txt
+#
+
+module Sapor
+  #
+  # Represents a dichotomy.
+  #
+  class Dichotomy
+    STANDARD_CONFIDENCE_LEVELS = [0.8, 0.9, 0.95, 0.99]
+    DEFAULT_CONFIDENCE_LEVEL = 0.95
+
+    def initialize(number, sample_size, population_size)
+      @number = number
+      @sample_size = sample_size
+      @population_size = population_size
+      @distribution = CombinationsDistribution.new
+      middle = @population_size / 2
+      @distribution[middle] = combinations_for(middle)
+      @previous_distribution = @distribution.dup
+    end
+
+    def combinations(value)
+      @distribution[value]
+    end
+
+    def confidence_interval(level = DEFAULT_CONFIDENCE_LEVEL)
+      value_confidence_interval(level).map { |x| x.to_f / @population_size }
+    end
+
+    def confidence_interval_values(level = DEFAULT_CONFIDENCE_LEVEL)
+      @distribution.confidence_interval_values(level)
+    end
+
+    def error_estimate
+      estimate_error
+    end
+    
+    def interval_probabilities(intervals)
+      @distribution.interval_probabilities(intervals, @population_size)
+    end
+
+    def most_probable_fraction
+      most_probable_value.to_f / @population_size
+    end
+
+    def most_probable_value
+      @distribution.most_probable_value
+    end
+
+    def refine
+      @previous_distribution = @distribution.dup
+      new_values = find_refinement_values
+      new_values.each do |value|
+        @distribution[value] = combinations_for(value)
+      end
+    end
+
+    def threshold_probability(threshold)
+      @distribution.threshold_probability(threshold, @population_size)
+    end
+
+    def value_confidence_interval(level = DEFAULT_CONFIDENCE_LEVEL)
+      @distribution.confidence_interval(level, @population_size)
+    end
+
+    def values
+      @distribution.values
+    end
+
+    private
+
+    def combinations_for(value)
+      dual_value = @population_size - value
+      dual_number = @sample_size - @number
+      if value < @number || dual_value < dual_number
+        0.to_lf
+      else
+        BinomialsCache.binomial(value, @number) * \
+          BinomialsCache.binomial(dual_value, dual_number)
+      end
+    end
+
+    def find_refinement_value_at_bottom
+      bottom = values.min
+      if bottom == 0
+        []
+      else
+        [(bottom.to_f / 3).round]
+      end
+    end
+
+    def find_refinement_values_between(low, high)
+      new_low = ((2 * low + high).to_f / 3).round
+      new_high = ((2 * high + low).to_f / 3).round
+      refinement_values = []
+      refinement_values << new_high unless new_high == high
+      refinement_values << new_low unless new_low == new_high || new_low == low
+      refinement_values
+    end
+
+    def find_refinement_values_in_between
+      sorted_values = values.sort
+      refinement_values = (0..(@distribution.size - 2)).to_a.map do |i|
+        find_refinement_values_between(sorted_values[i], sorted_values[i + 1])
+      end
+      refinement_values.flatten
+    end
+
+    def find_refinement_value_at_top
+      top = values.max
+      if top == @population_size
+        []
+      else
+        [((2.to_f * @population_size + top) / 3).round]
+      end
+    end
+
+    def find_refinement_values
+      find_refinement_value_at_bottom + find_refinement_values_in_between +
+        find_refinement_value_at_top
+    end
+
+    def previous_confidence_interval(level)
+      @previous_distribution.confidence_interval(level, @population_size).map do |x|
+        x.to_f / @population_size
+      end
+    end
+
+    def previous_most_probable_fraction
+      @previous_distribution.most_probable_value.to_f / @population_size
+    end
+
+    def estimate_error
+      if @distribution.size == @population_size + 1
+        0
+      else
+        ci_error_estimates = STANDARD_CONFIDENCE_LEVELS.map do |l|
+          ci = confidence_interval(l)
+          pci = previous_confidence_interval(l)
+          [(ci.first - pci.first).abs, (ci.last - pci.last).abs].max
+        end
+        [1.to_f / @distribution.size,
+         (most_probable_fraction - previous_most_probable_fraction).abs,
+         ci_error_estimates.max].max
+      end
+    end
+  end
+end

data/lib/sapor/first_past_the_post.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+#
+# Statistical Analysis of Polling Results (SAPoR)
+# Copyright (C) 2016 Filip van Laenen <f.a.vanlaenen@ieee.org>
+#
+# This file is part of SAPoR.
+#
+# SAPoR is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# SAPoR is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You can find a copy of the GNU General Public License in /doc/gpl.txt
+#
+
+module Sapor
+  #
+  # Class representing an electoral system based on the First-Past-The-Post
+  # system.
+  #
+  class FirstPastThePost
+    def initialize(last_election_result, last_detailed_election_result)
+      @last_election_result = last_election_result
+      @last_detailed_election_result = last_detailed_election_result
+    end
+
+    def project(simulation)
+      multiplicators = calculate_multiplicators(simulation)
+      result = create_empty_result(simulation)
+      @last_detailed_election_result.each_value do |local_last_result|
+        winner = local_winner(local_last_result, multiplicators)
+        if result.key?(winner)
+          result[winner] += 1
+        else
+          result[winner] = 1
+        end
+      end
+      result
+    end
+
+    private
+
+    def calculate_multiplicators(simulation)
+      simulation_sum = simulation.values.inject(:+)
+      last_election_sum = @last_election_result.values.inject(:+)
+      multiplicators = {}
+      simulation.each_key do |choice|
+        new_fraction = simulation[choice].to_f / simulation_sum
+        last_fraction = @last_election_result[choice].to_f / last_election_sum
+        multiplicators[choice] = new_fraction / last_fraction
+      end
+      multiplicators
+    end
+
+    def create_empty_result(simulation)
+      result = {}
+      simulation.each_key do |choice|
+        result[choice] = 0
+      end
+      result[OTHER] = 0
+      result
+    end
+
+    def local_winner(local_last_result, multiplicators)
+      new_local_result = {}
+      local_last_result.each_pair do |choice, votes|
+        if multiplicators.key?(choice)
+          new_local_result[choice] = votes * multiplicators[choice]
+        else
+          new_local_result[choice] = votes
+        end
+      end
+      max_votes = new_local_result.values.max
+      winner = new_local_result.select { |_k, v| v.equal?(max_votes) }.keys.first
+      multiplicators.key?(winner) ? winner : OTHER
+    end
+  end
+end

data/lib/sapor/largest_remainder.rb

@@ -0,0 +1,118 @@
+# Statistical Analysis of Polling Results (SAPoR)
+# Copyright (C) 2016 Filip van Laenen <f.a.vanlaenen@ieee.org>
+#
+# This file is part of SAPoR.
+#
+# SAPoR is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# SAPoR is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You can find a copy of the GNU General Public License in /doc/gpl.txt
+#
+
+module Sapor
+  #
+  # Class representing a largest remainder electoral system with only one
+  # district.
+  #
+  class LargestRemainder
+    def initialize(no_of_seats, quota_class, threshold = 0, full_quota = false,
+                   bonus = 0, other_eligible = true)
+      @no_of_seats = no_of_seats
+      @quota_class = quota_class
+      @threshold = threshold
+      @full_quota = full_quota
+      @bonus = bonus
+      @other_eligible = other_eligible
+    end
+
+    def project(simulation)
+      result = create_empty_result(simulation)
+      thresholded_simulation = apply_threshold(simulation)
+      total_votes = if @full_quota
+                      simulation.values.inject(:+)
+                    else
+                      thresholded_simulation.values.inject(:+)
+                    end
+      quota = @quota_class.get(total_votes, @no_of_seats)
+      add_automatic_seats(result, thresholded_simulation, quota)
+      add_remaining_seats(result, thresholded_simulation, quota)
+      result[simulation.max_by(&:last)[0]] += @bonus
+      result
+    end
+
+    private
+
+    def add_automatic_seats(result, simulation, quota)
+      simulation.each_pair do |choice, votes|
+        result[choice] = (votes / quota).floor
+      end
+    end
+
+    def add_remaining_seats(result, simulation, quota)
+      remainders = calculate_remainders(simulation, quota)
+      choices = simulation.keys.sort { |a, b| remainders[b] <=> remainders[a] }
+      remaining_seats = @no_of_seats - result.values.inject(:+)
+      choices.slice(0, remaining_seats).each { |c| result[c] += 1 }
+    end
+
+    def apply_threshold(simulation)
+      threshold = simulation.values.inject(:+).to_f * @threshold
+      thresholded_simulation = {}
+      simulation.each_pair do |choice, votes|
+        thresholded_simulation[choice] = votes >= threshold ? votes : 0
+      end
+      thresholded_simulation[OTHER] = 0 unless @other_eligible
+      thresholded_simulation
+    end
+
+    def calculate_remainders(simulation, quota)
+      remainders = {}
+      simulation.each_pair do |choice, votes|
+        remainders[choice] = votes / quota - (votes / quota).floor
+      end
+      remainders
+    end
+
+    def create_empty_result(simulation)
+      result = {}
+      simulation.each_key do |choice|
+        result[choice] = 0
+      end
+      result[OTHER] = 0
+      result
+    end
+  end
+
+  #
+  # Class calculating the Hare quota.
+  #
+  class HareQuota
+    def self.get(total_votes, no_of_seats)
+      total_votes.to_f / no_of_seats
+    end
+  end
+
+  #
+  # Class calculating the Droop quota.
+  #
+  class DroopQuota
+    def self.get(total_votes, no_of_seats)
+      1 + total_votes.to_f / (1 + no_of_seats)
+    end
+  end
+
+  #
+  # Class calculating the Hagenbach-Bischoff quota.
+  #
+  class HagenbachBischoffQuota
+    def self.get(total_votes, no_of_seats)
+      total_votes.to_f / (1 + no_of_seats)
+    end
+  end
+end

data/lib/sapor/log4r_logger.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+#
+# Statistical Analysis of Polling Results (SAPoR)
+# Copyright (C) 2016 Filip van Laenen <f.a.vanlaenen@ieee.org>
+#
+# This file is part of SAPoR.
+#
+# SAPoR is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# SAPoR is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You can find a copy of the GNU General Public License in /doc/gpl.txt
+#
+
+module Sapor
+  #
+  # Builder to create Log4rLoggers.
+  #
+  class Log4rLoggerBuilder
+    def create_logger
+      Log4rLogger.new
+    end
+  end
+
+  require 'rubygems'
+  require 'log4r'
+  #
+  # Logger using Log4r.
+  #
+  class Log4rLogger
+    def initialize
+      @logger = Log4r::Logger.new 'stdout'
+      stdout_outputter = Log4r::Outputter.stdout
+      @logger.outputters = stdout_outputter
+      stdout_format = Log4r::PatternFormatter.new(pattern: '%d %l: %m')
+      stdout_outputter.formatter = stdout_format
+      @logger.level = Log4r::INFO
+    end
+
+    def info(message)
+      @logger.info(message)
+    end
+  end
+end

data/lib/sapor/log_facade.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+#
+# Statistical Analysis of Polling Results (SAPoR)
+# Copyright (C) 2016 Filip van Laenen <f.a.vanlaenen@ieee.org>
+#
+# This file is part of SAPoR.
+#
+# SAPoR is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# SAPoR is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You can find a copy of the GNU General Public License in /doc/gpl.txt
+#
+
+module Sapor
+  #
+  # A facade for logging.
+  #
+  class LogFacade
+    @logger_builder = nil
+
+    class << self
+      attr_writer :logger_builder
+    end
+
+    def self.builder
+      @logger_builder = Log4rLoggerBuilder.new if @logger_builder.nil?
+      @logger_builder
+    end
+
+    def self.create_logger
+      builder.create_logger
+    end
+  end
+end