sapor 0.3.3

data/lib/sapor/multi_district_leveled_proportional.rb

@@ -0,0 +1,64 @@
+# 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 a multi-district proportional electoral system with a
+  # second round of leveling seats.
+  #
+  class MultiDistrictLeveledProportional
+    def initialize(last_election_result, last_detailed_election_result,
+                   seat_distribution, leveling_seats, leveling_threshold,
+                   denominators_class)
+      @proportional = MultiDistrictProportional.new(last_election_result,
+                                                    last_detailed_election_result,
+                                                    seat_distribution, denominators_class)
+      @leveling_seats = leveling_seats
+      @leveling_threshold = leveling_threshold
+      @denominators_class = denominators_class
+    end
+
+    def project(simulation)
+      result = @proportional.project(simulation)
+      threshold = @leveling_threshold * simulation.values.inject(:+)
+      quotients = []
+      simulation.each_pair do |choice, votes|
+        next if votes < threshold
+        denominators(result[choice]).each do |d|
+          quotients << [choice, votes.to_f / d]
+        end
+      end
+      seats = quotients.sort { |a, b| b.last <=> a.last }.map(&:first).slice(0, @leveling_seats)
+      seats.each do |seat|
+        if result.key?(seat)
+          result[seat] += 1
+        else
+          result[seat] = 1
+        end
+      end
+      result
+    end
+
+    private
+
+    def denominators(seats)
+      @denominators_class.get(seats + @leveling_seats).reverse_each.take(@leveling_seats)
+    end
+  end
+end

data/lib/sapor/multi_district_proportional.rb

@@ -0,0 +1,123 @@
+#
+# 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 proportional electoral system with more than one
+  # district.
+  #
+  class MultiDistrictProportional
+    def initialize(last_election_result, last_detailed_election_result,
+                   seat_distribution, denominators_class, threshold = 0,
+                   national_threshold = 0)
+      @last_election_result = last_election_result
+      @last_detailed_election_result = last_detailed_election_result
+      @seat_distribution = seat_distribution
+      @denominators_class = denominators_class
+      @threshold = threshold
+      @national_threshold = national_threshold
+    end
+
+    def project(simulation)
+      allowed_parties = []
+      unless @national_threshold.zero?
+        threshold = @national_threshold * simulation.values.inject(:+)
+        simulation.each_pair do |choice, votes|
+          allowed_parties << choice if votes >= threshold
+        end
+      end
+      multiplicators = calculate_multiplicators(simulation)
+      result = create_empty_result(simulation)
+      @last_detailed_election_result.each_pair do |name, local_last_result|
+        no_of_seats = @seat_distribution[name]
+        seats = local_seats(no_of_seats, local_last_result, multiplicators,
+                            allowed_parties)
+        add_seats_to_result(result, seats)
+      end
+      result
+    end
+
+    private
+
+    def add_seats_to_result(result, seats)
+      seats.each do |seat|
+        if result.key?(seat)
+          result[seat] += 1
+        else
+          result[seat] = 1
+        end
+      end
+    end
+
+    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_votes(local_last_result, multiplicators)
+      local_votes = {}
+      local_last_result.each_pair do |choice, votes|
+        local_votes[choice] = if multiplicators.key?(choice)
+                                votes * multiplicators[choice]
+                              else
+                                votes
+                              end
+      end
+      local_votes
+    end
+
+    def local_quotients(local_votes, local_threshold, no_of_seats,
+                        allowed_parties)
+      local_quotients = []
+      local_votes.each_pair do |choice, new_value|
+        next unless allowed_parties.empty? || allowed_parties.include?(choice)
+        next if new_value < local_threshold
+        @denominators_class.get(no_of_seats).each do |d|
+          local_quotients << [choice, new_value.to_f / d]
+        end
+      end
+      local_quotients
+    end
+
+    def local_seats(no_of_seats, local_last_result, multiplicators,
+                    allowed_parties)
+      local_votes = local_votes(local_last_result, multiplicators)
+      local_threshold = local_votes.values.inject(:+).to_f * @threshold
+      local_quotients = local_quotients(local_votes, local_threshold,
+                                        no_of_seats, allowed_parties)
+      sorted_quotients = local_quotients.sort { |a, b| b.last <=> a.last }
+      sorted_quotients.map(&:first).slice(0, no_of_seats)
+    end
+  end
+end

data/lib/sapor/multi_district_variable_threshold_proportional.rb

@@ -0,0 +1,128 @@
+#
+# 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 proportional electoral system with more than one
+  # district.
+  #
+  class MultiDistrictVariableThresholdProportional
+    def initialize(last_election_result, last_detailed_election_result,
+                   seat_distribution, denominators_class,
+                   party_list_threshold, coalition_list_threshold,
+                   coalition_lists, minority_lists)
+      @last_election_result = last_election_result
+      @last_detailed_election_result = last_detailed_election_result
+      @seat_distribution = seat_distribution
+      @denominators_class = denominators_class
+      @party_list_threshold = party_list_threshold
+      @coalition_list_threshold = coalition_list_threshold
+      @coalition_lists = coalition_lists
+      @minority_lists = minority_lists
+    end
+
+    def project(simulation)
+      allowed_parties = []
+      total_votes = simulation.values.inject(:+)
+      party_list_threshold = @party_list_threshold * total_votes
+      coalition_list_threshold = @coalition_list_threshold * total_votes
+      simulation.each_pair do |choice, votes|
+        next unless @minority_lists.include?(choice) ||
+                    @coalition_lists.include?(choice) &&
+                    votes >= coalition_list_threshold ||
+                    !@coalition_lists.include?(choice) &&
+                    votes >= party_list_threshold
+        allowed_parties << choice
+      end
+      multiplicators = calculate_multiplicators(simulation)
+      result = create_empty_result(simulation)
+      @last_detailed_election_result.each_pair do |name, local_last_result|
+        no_of_seats = @seat_distribution[name]
+        seats = local_seats(no_of_seats, local_last_result, multiplicators,
+                            allowed_parties)
+        add_seats_to_result(result, seats)
+      end
+      result
+    end
+
+    private
+
+    def add_seats_to_result(result, seats)
+      seats.each do |seat|
+        if result.key?(seat)
+          result[seat] += 1
+        else
+          result[seat] = 1
+        end
+      end
+    end
+
+    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_votes(local_last_result, multiplicators)
+      local_votes = {}
+      local_last_result.each_pair do |choice, votes|
+        local_votes[choice] = if multiplicators.key?(choice)
+                                votes * multiplicators[choice]
+                              else
+                                votes
+                              end
+      end
+      local_votes
+    end
+
+    def local_quotients(local_votes, no_of_seats, allowed_parties)
+      local_quotients = []
+      local_votes.each_pair do |choice, new_value|
+        next unless allowed_parties.empty? || allowed_parties.include?(choice)
+        @denominators_class.get(no_of_seats).each do |d|
+          local_quotients << [choice, new_value.to_f / d]
+        end
+      end
+      local_quotients
+    end
+
+    def local_seats(no_of_seats, local_last_result, multiplicators,
+                    allowed_parties)
+      local_votes = local_votes(local_last_result, multiplicators)
+      local_quotients = local_quotients(local_votes, no_of_seats,
+                                        allowed_parties)
+      sorted_quotients = local_quotients.sort { |a, b| b.last <=> a.last }
+      sorted_quotients.map(&:first).slice(0, no_of_seats)
+    end
+  end
+end

data/lib/sapor/number_formatter.rb

@@ -0,0 +1,45 @@
+# 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
+  #
+  # Module to format numbers.
+  #
+  module NumberFormatter
+    def three_digits_percentage(number)
+      if number >= 0.9995 || number < 0.000005
+        sprintf('%.0f', number * 100) + '%'
+      elsif number >= 0.09995
+        sprintf('%.1f', number * 100) + '%'
+      elsif number >= 0.009995
+        sprintf('%.2f', number * 100) + '%'
+      else
+        sprintf('%.3f', number * 100) + '%'
+      end
+    end
+
+    def six_char_percentage(number)
+      sprintf('%5.1f', number * 100) + '%'
+    end
+
+    def with_thousands_separator(integer)
+      integer.to_s.reverse.gsub(/...(?=.)/, '\&,').reverse
+    end
+  end
+end

data/lib/sapor/options.rb

@@ -0,0 +1,73 @@
+# 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 set of options.
+  #
+  class Options
+    DEFAULT_MAX_ERROR = 0.001
+    DEFAULT_MAX_POLYCHOTOMY_ITERATIONS = 2 ** 25
+    DEFAULT_MIN_DICHOTOMIES_ITERATIONS = 0
+    DEFAULT_MIN_POLYCHOTOMY_ITERATIONS = 2 ** 20
+
+    MAX_ERROR_KEY = 'emx'
+    MAX_POLYCHOTOMY_ITERATIONS_KEY = 'pmx'
+    MIN_DICHOTOMIES_ITERATIONS_KEY = 'dmn'
+    MIN_POLYCHOTOMY_ITERATIONS_KEY = 'pmn'
+    
+    FLOAT_OPTIONS = [MAX_ERROR_KEY]
+    INTEGER_OPTIONS = [MAX_POLYCHOTOMY_ITERATIONS_KEY, MIN_DICHOTOMIES_ITERATIONS_KEY, MIN_POLYCHOTOMY_ITERATIONS_KEY]
+
+    def initialize(arguments)
+      @hash = { MAX_ERROR_KEY => DEFAULT_MAX_ERROR,
+        MAX_POLYCHOTOMY_ITERATIONS_KEY => DEFAULT_MAX_POLYCHOTOMY_ITERATIONS,
+        MIN_DICHOTOMIES_ITERATIONS_KEY => DEFAULT_MIN_DICHOTOMIES_ITERATIONS,
+        MIN_POLYCHOTOMY_ITERATIONS_KEY => DEFAULT_MIN_POLYCHOTOMY_ITERATIONS }
+      arguments.each do | argument |
+        key_value = argument[1..-1].split('=')
+        key = key_value.first
+        value = key_value.last
+        if INTEGER_OPTIONS.include?(key)
+          value = value.to_i
+        elsif FLOAT_OPTIONS.include?(key)
+          value = value.to_f
+        end
+        @hash[key] = value
+      end
+    end
+    
+    def max_error
+      @hash[MAX_ERROR_KEY]
+    end
+    
+    def max_polychotomy_iterations
+      @hash[MAX_POLYCHOTOMY_ITERATIONS_KEY]
+    end
+
+    def min_dichotomies_iterations
+      @hash[MIN_DICHOTOMIES_ITERATIONS_KEY]
+    end
+
+    def min_polychotomy_iterations
+      @hash[MIN_POLYCHOTOMY_ITERATIONS_KEY]
+    end
+  end
+end

data/lib/sapor/poll.rb

@@ -0,0 +1,286 @@
+#
+# 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
+#
+
+require 'yaml'
+
+module Sapor
+  OTHER = 'Other'.freeze
+
+  #
+  # Represents a poll.
+  #
+  class Poll
+    include NumberFormatter
+    attr_reader :area, :logger, :type
+
+    AREA_KEY = 'Area'.freeze
+
+    BELGIAN_AREAS = [BelgiumBrussels.instance, BelgiumFlanders.instance,
+                     BelgiumWallonia.instance, Flanders.instance,
+                     Wallonia.instance].freeze
+    CATALONIAN_AREAS = [Catalonia.instance,
+                        CataloniaWithJuntsPerCatalunya.instance,
+                        CataloniaWithoutJuntsPelSi.instance].freeze
+    DANISH_AREAS = [Denmark.instance, DenmarkWithE.instance,
+                    DenmarkWithEAndP.instance, DenmarkWithP.instance].freeze
+    EUROPEAN_UNION_AREAS = [EuropeanUnion27Austria.instance,
+                            EuropeanUnion27Croatia.instance,
+                            EuropeanUnion27Denmark.instance,
+                            EuropeanUnion27Estonia.instance,
+                            EuropeanUnion27Finland.instance,
+                            EuropeanUnion27Ireland.instance,
+                            EuropeanUnion27IrelandWithIa.instance,
+                            EuropeanUnion27Italy.instance,
+                            EuropeanUnion27Netherlands.instance,                            
+                            EuropeanUnion27Poland.instance,
+                            EuropeanUnion27Romania.instance,
+                            EuropeanUnion27Slovakia.instance,
+                            EuropeanUnion27Spain.instance,
+                            EuropeanUnion27Sweden.instance,
+                            EuropeanUnionAustria.instance,
+                            EuropeanUnionBulgaria.instance,
+                            EuropeanUnionCroatia.instance,
+                            EuropeanUnionCyprus.instance,
+                            EuropeanUnionCzechRepublic.instance,
+                            EuropeanUnionDenmark.instance,
+                            EuropeanUnionEstonia.instance,
+                            EuropeanUnionFinland.instance,
+                            EuropeanUnionFlanders.instance,
+                            EuropeanUnionFrance.instance,
+                            EuropeanUnionFrance2019.instance,
+                            EuropeanUnionFrenchCommunityOfBelgium.instance,
+                            EuropeanUnionGermany.instance,
+                            EuropeanUnionGreatBritain.instance,
+                            EuropeanUnionGreece.instance,
+                            EuropeanUnionHungary.instance,
+                            EuropeanUnionIreland.instance,
+                            EuropeanUnionIrelandWithIa.instance,
+                            EuropeanUnionItaly.instance,
+                            EuropeanUnionLatvia.instance,
+                            EuropeanUnionLithuania.instance,
+                            EuropeanUnionLuxembourg.instance,
+                            EuropeanUnionMalta.instance,
+                            EuropeanUnionNetherlands.instance,
+                            EuropeanUnionNorthernIreland.instance,
+                            EuropeanUnionPoland.instance,
+                            EuropeanUnionPortugal.instance,
+                            EuropeanUnionRomania.instance,
+                            EuropeanUnionSlovakia.instance,
+                            EuropeanUnionSlovenia.instance,
+                            EuropeanUnionSpain.instance,
+                            EuropeanUnionSweden.instance].freeze
+    LATVIAN_AREAS = [Latvia.instance, LatviaKpv.instance, \
+                     LatviaKpvPar.instance, LatviaKpvPPar.instance].freeze
+    NORWEGIAN_AREAS = [Norway.instance, NorwegianMunicipality::BERGEN,
+                       NorwegianMunicipality::OSLO,
+                       NorwegianMunicipality::TRONDHEIM].freeze
+    POLISH_AREAS = [Poland.instance,
+                    PolandWithKoAndLWithoutNPoRAndZl.instance,
+                    PolandWithKoKonfKpLAndZpWithoutKK15NPisPoPslRAndZl.instance,
+                    PolandWithKoSldAndWiWithoutNPoAndZl.instance,
+                    PolandWithSldAndWiWithoutZL.instance,
+                    PolandWithSldWithoutZL.instance].freeze
+    PORTUGUESE_AREAS = [Portugal.instance,
+                        PortugalWithAAndChWithoutPaf.instance,
+                        PortugalWithAAndIlWithoutPaf.instance,
+                        PortugalWithAChAndIlWithoutPaf.instance,
+                        PortugalWithAWithoutPaf.instance,
+                        PortugalWithChAndIlWithoutPaf.instance,
+                        PortugalWithoutPaf.instance].freeze
+    AREAS_MAP = {}
+    (BELGIAN_AREAS + CATALONIAN_AREAS + DANISH_AREAS + EUROPEAN_UNION_AREAS + \
+     LATVIAN_AREAS + NORWEGIAN_AREAS + POLISH_AREAS + PORTUGUESE_AREAS + \
+     [Austria.instance, Estonia.instance, Finland.instance,
+      FinlandWithSin.instance, France.instance, Greece.instance,
+      Hungary.instance, Iceland.instance, Luxembourg.instance,
+      Netherlands.instance, Slovakia.instance, Slovenia.instance,
+      Spain.instance, Sweden.instance, Sweden20140914.instance,
+      UnitedKingdom.instance, UnitedKingdomWithBrexit.instance,
+      UnitedKingdomWithBrexitAndChuk.instance, UnitedKingdomWithTig.instance,
+      Utopia.instance]).map do |area|
+      AREAS_MAP[area.area_code] = area
+    end
+
+    TYPE_KEY = 'Type'.freeze
+    REFERENDUM_TYPE_VALUE = 'Referendum'.freeze
+    ELECTION_TYPE_VALUE = 'Election'.freeze
+
+    DEFAULT_CONFIDENCE_LEVEL = 0.95
+
+    def initialize(filename, metadata, results)
+      @filename = filename
+      @logger = LogFacade.create_logger
+      @area_code = metadata.delete(AREA_KEY)
+      @area = Poll.lookup_area(@area_code)
+      @type = metadata.delete(TYPE_KEY)
+      @results = interpret(results)
+    end
+
+    def analyze(options)
+      analyze_as_dichotomies(options)
+      analyze_as_polychotomy(options)
+      @logger.info('Done.')
+    end
+
+    def continue_analysis(options)
+      @logger = LogFacade.create_logger
+      @logger.info('Continuing the analysis as a polychotomy...')
+      @area = Poll.lookup_area(@area_code)
+      @analysis.revive_volatile_fields(@logger)
+      analyze_until_convergence(options)
+      @logger.info('Done.')
+    end
+
+    def confidence_interval(choice, level = DEFAULT_CONFIDENCE_LEVEL)
+      @analysis.confidence_interval(choice, level) unless @analysis.nil?
+    end
+
+    def most_probable_fraction(choice)
+      @analysis.most_probable_fraction(choice) unless @analysis.nil?
+    end
+
+    def most_probable_value(choice)
+      @analysis.most_probable_value(choice) unless @analysis.nil?
+    end
+
+    def result(choice)
+      @results[choice]
+    end
+
+    def encode_with(coder)
+      (instance_variables - [:@area, :@logger]).each do |var|
+        var = var.to_s
+        coder[var.gsub('@', '')] = eval(var)
+      end
+    end
+
+    def self.lookup_area(area_code)
+      AREAS_MAP[area_code]
+    end
+
+    private
+
+    def self.line_to_hash(line, current, results)
+      if line.chomp.eql?('==')
+        current = results
+      else
+        elements = line.chomp.split('=')
+        current[elements.first] = elements.last
+      end
+      current
+    end
+
+    def self.as_hashes(lines)
+      metadata = {}
+      results = {}
+      current = metadata
+      lines.each do |line|
+        current = line_to_hash(line, current, results)
+      end
+      [metadata, results]
+    end
+
+    def self.from_lines(filename, lines)
+      hashes = as_hashes(lines)
+      metadata = hashes.first
+      results = hashes.last
+      new(filename, metadata, results)
+    end
+
+    def self.from_file(filename)
+      from_lines(filename, File.open(filename))
+    end
+
+    def interpret(results)
+      interpreted = {}
+      results.each_pair do |key, value|
+        interpreted[key] = value.to_i
+      end
+      interpreted
+    end
+
+    def population_size
+      @area.population_size
+    end
+
+    def referendum?
+      @type == REFERENDUM_TYPE_VALUE
+    end
+
+    def threshold
+      if referendum?
+        0.5
+      else
+        @area.threshold
+      end
+    end
+
+    def analyze_until_convergence(options)
+      while should_continue_analysis?(@analysis, options)
+        @analysis.refine
+        @logger.info(@analysis.report)
+        @logger.info('Error estimate: ε ≤ ' +
+                     three_digits_percentage(@analysis.error_estimate) +
+                     '.')
+        @logger.info(@analysis.progress_report)
+        @analysis.write_outputs(@filename)
+        save_state
+      end
+    end
+
+    def should_continue_analysis?(analysis, options)
+      analysis.kind_of?(Dichotomies) \
+        && (options.min_dichotomies_iterations > analysis.size \
+            || analysis.error_estimate > options.max_error) \
+        || analysis.kind_of?(Polychotomy) \
+           && options.max_polychotomy_iterations > analysis.no_of_simulations \
+           && (options.min_polychotomy_iterations > analysis.no_of_simulations \
+               || analysis.error_estimate > options.max_error)
+    end
+
+    def analyze_as_dichotomies(options)
+      @logger.info('Analyzing as a set of dichotomies...')
+      @analysis = Dichotomies.new(@results, population_size, threshold)
+      analyze_until_convergence(options)
+    end
+
+    def analyze_as_polychotomy(options)
+      @logger.info('Analyzing as a polychotomy...')
+      if referendum?
+        @analysis = ReferendumPolychotomy.new(@results, @area, @analysis,
+                                              options.max_error)
+      else
+        @analysis = RepresentativesPolychotomy.new(@results, @area, @analysis,
+                                                   options.max_error, @logger)
+      end
+      analyze_until_convergence(options)
+    end
+
+    def save_state
+      new_yaml_file = @filename.gsub('.poll', '-state-new.yaml')
+      open(new_yaml_file, 'w') do |file|
+        file.write(to_yaml)
+      end
+      yaml_file = @filename.gsub('.poll', '-state.yaml')
+      old_yaml_file = @filename.gsub('.poll', '-state-old.yaml')
+      File.delete(old_yaml_file) if File.exist?(old_yaml_file)
+      File.rename(yaml_file, old_yaml_file) if File.exist?(yaml_file)
+      File.rename(new_yaml_file, yaml_file)
+    end
+  end
+end