sapor 0.1b1 → 0.2a1

data/lib/sapor/poll.rb

@@ -1,7 +1,6 @@
-# encoding: utf-8
 #
 # Statistical Analysis of Polling Results (SAPoR)
-# Copyright (C) 2014 Filip van Laenen <f.a.vanlaenen@ieee.org>
+# Copyright (C) 2016 Filip van Laenen <f.a.vanlaenen@ieee.org>
 #
 # This file is part of SAPoR.
 #
@@ -17,33 +16,137 @@
 # You can find a copy of the GNU General Public License in /doc/gpl.txt
 #
 
+require 'yaml'
+
 module Sapor
-  OTHER = 'Other'
+  OTHER = 'Other'.freeze
 
   #
   # Represents a poll.
   #
   class Poll
     include NumberFormatter
-    attr_reader :area, :logger
+    attr_reader :area, :logger, :type
+
+    AREA_KEY = 'Area'.freeze
 
-    AREA_KEY = 'Area'
+    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 = {}
-    [Catalonia.instance, Norway.instance, UnitedKingdom.instance, Utopia.instance].map { |area| AREAS_MAP[area.area_code] = area }
+    (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
 
-    def initialize(metadata, results)
+    DEFAULT_CONFIDENCE_LEVEL = 0.95
+
+    def initialize(filename, metadata, results)
+      @filename = filename
       @logger = LogFacade.create_logger
-      @area = lookup_area(metadata.delete(AREA_KEY))
+      @area_code = metadata.delete(AREA_KEY)
+      @area = Poll.lookup_area(@area_code)
+      @type = metadata.delete(TYPE_KEY)
       @results = interpret(results)
     end
 
-    def analyze(max_error = 0.001)
-      analyze_as_dichotomies(max_error)
-      analyze_as_polychotomy(max_error)
+    def analyze(options)
+      analyze_as_dichotomies(options)
+      analyze_as_polychotomy(options)
       @logger.info('Done.')
     end
 
-    def confidence_interval(choice, level = 0.95)
+    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
 
@@ -59,6 +162,17 @@ module Sapor
       @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)
@@ -81,15 +195,15 @@ module Sapor
       [metadata, results]
     end
 
-    def self.from_lines(lines)
+    def self.from_lines(filename, lines)
       hashes = as_hashes(lines)
       metadata = hashes.first
       results = hashes.last
-      new(metadata, results)
+      new(filename, metadata, results)
     end
 
     def self.from_file(filename)
-      from_lines(File.open(filename))
+      from_lines(filename, File.open(filename))
     end
 
     def interpret(results)
@@ -100,38 +214,73 @@ module Sapor
       interpreted
     end
 
-    def lookup_area(area_code)
-      AREAS_MAP[area_code]
-    end
-
     def population_size
       @area.population_size
     end
 
+    def referendum?
+      @type == REFERENDUM_TYPE_VALUE
+    end
+
     def threshold
-      @area.threshold
+      if referendum?
+        0.5
+      else
+        @area.threshold
+      end
     end
 
-    def analyze_until_convergence(max_error)
-      while @analysis.error_estimate > max_error
+    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('Error estimate: ε ≤ ' +
+                     three_digits_percentage(@analysis.error_estimate) +
+                     '.')
         @logger.info(@analysis.progress_report)
+        @analysis.write_outputs(@filename)
+        save_state
       end
     end
 
-    def analyze_as_dichotomies(max_error)
+    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(max_error)
+      analyze_until_convergence(options)
     end
 
-    def analyze_as_polychotomy(max_error)
+    def analyze_as_polychotomy(options)
       @logger.info('Analyzing as a polychotomy...')
-      @analysis = Polychotomy.new(@results, @area, @analysis, max_error)
-      analyze_until_convergence(max_error)
+      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