sapor 0.1b1

data/spec/unit/combinations_distribution_spec.rb

@@ -0,0 +1,241 @@
+# encoding: utf-8
+#
+# Statistical Analysis of Polling Results (SAPoR)
+# Copyright (C) 2014 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 'spec_helper'
+
+describe Sapor::CombinationsDistribution, '#new' do
+  it 'creates an empty distribution' do
+    distribution = Sapor::CombinationsDistribution.new
+    expect(distribution).to be_empty
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#[]=' do
+  it 'sets a value-combinations pair' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[1] = 2
+    expect(distribution[1]).to eq(2)
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#+' do
+  it 'adds two combiation distributions together' do
+    a = Sapor::CombinationsDistribution.new
+    a[10] = 2
+    a[21] = 3
+    a[23] = 11
+    b = Sapor::CombinationsDistribution.new
+    b[10] = 5
+    b[21] = 7
+    b[29] = 13
+    sum = Sapor::CombinationsDistribution.new
+    sum[10] = 7
+    sum[21] = 10
+    sum[23] = 11
+    sum[29] = 13
+    expect((a + b)[10]).to eq(sum[10])
+    expect((a + b)[21]).to eq(sum[21])
+    expect((a + b)[23]).to eq(sum[23])
+    expect((a + b)[29]).to eq(sum[29])
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#confidence_interval' do
+  it 'returns the single value as boundaries (default)' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[5] = 2
+    expect(distribution.confidence_interval(0.95)).to eq([5, 5])
+  end
+
+  it 'returns the full interval as boundaries if single value (extensive)' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[5] = 2
+    expect(distribution.confidence_interval(0.95, 10)).to eq([0, 10])
+  end
+
+  it 'returns the boundaries (default)' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[3] = 2
+    distribution[7] = 2
+    expect(distribution.confidence_interval(0.95)).to eq([3, 7])
+  end
+
+  it 'returns the full interval as boundaries (extensive)' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[3] = 2
+    distribution[7] = 2
+    expect(distribution.confidence_interval(0.95, 10)).to eq([0, 10])
+  end
+
+  it 'returns the full interval if level too high' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[5] = 1
+    distribution[10] = 98
+    distribution[15] = 1
+    expect(distribution.confidence_interval(0.99)).to eq([5, 15])
+  end
+
+  it 'returns the values in between as boundaries (even)' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[5] = 1
+    distribution[10] = 98
+    distribution[15] = 1
+    expect(distribution.confidence_interval(0.95)).to eq([8, 12])
+  end
+
+  it 'returns the values in between as boundaries (odd)' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[6] = 1.to_lf
+    distribution[10] = 98.to_lf
+    distribution[14] = 1.to_lf
+    expect(distribution.confidence_interval(0.95)).to eq([8, 12])
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#confidence_interval_values' do
+  it 'extracts the single value as confidence interval value' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[5] = 2.to_lf
+    expect(distribution.confidence_interval_values(0.95)).to eq([5])
+  end
+
+  it 'extracts all values as confidence intervalue values' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[3] = 2.to_lf
+    distribution[7] = 2.to_lf
+    expect(distribution.confidence_interval_values(0.95).sort).to eq([3, 7])
+  end
+
+  it 'extracts the middle values as confidence interval values' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[5] = 1.to_lf
+    distribution[10] = 98.to_lf
+    distribution[15] = 1.to_lf
+    expect(distribution.confidence_interval_values(0.95)).to eq([10])
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#empty?' do
+  it 'returns true if no value-combinations pair has been added' do
+    distribution = Sapor::CombinationsDistribution.new
+    expect(distribution.empty?).to be true
+  end
+
+  it 'returns false if a value-combinations pair has been added' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[1] = 2.to_lf
+    expect(distribution.empty?).to be false
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#most_probable_rounded_fraction' do
+  it "returns the median rounded fraction if there's more than one with" \
+     ' maximal probability' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[500] = 2.to_lf
+    expect(distribution.most_probable_rounded_fraction(1000)).to eq(0.5)
+  end
+
+  it 'returns the rounded fraction with the maximal probability' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[199] = 2.to_lf
+    distribution[200] = 3.to_lf
+    distribution[201] = 2.to_lf
+    expect(distribution.most_probable_rounded_fraction(1000)).to eq(0.2)
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#most_probable_value' do
+  it "returns the single value if there's only one value" do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[1] = 2
+    expect(distribution.most_probable_value).to eq(1)
+  end
+
+  it 'returns the first of two values if that has the greatest number ' \
+     'of combinations' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[1] = 2
+    distribution[2] = 1
+    expect(distribution.most_probable_value).to eq(1)
+  end
+
+  it 'returns the second of two values if that has the greatest number ' \
+     'of combinations' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[1] = 1
+    distribution[2] = 2
+    expect(distribution.most_probable_value).to eq(2)
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#size' do
+  it 'returns 0 for an empty distribution' do
+    distribution = Sapor::CombinationsDistribution.new
+    expect(distribution.size).to eq(0)
+  end
+
+  it 'returns 1 when a value-combinations pair has been added' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[1] = 2
+    expect(distribution.size).to eq(1)
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#threshold_probability' do
+  it 'returns 1 if the single value is above the threshold' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[5] = 2.to_lf
+    expect(distribution.threshold_probability(0.1, 10)).to eq(1)
+  end
+
+  it 'returns 0 if the single value is below the threshold' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[5] = 2.to_lf
+    expect(distribution.threshold_probability(0.6, 10)).to eq(0)
+  end
+
+  it 'returns 0.8 if the threshold is between combinations 2 and 8' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[2] = 2.to_lf
+    distribution[7] = 8.to_lf
+    expect(distribution.threshold_probability(0.5, 10)).to eq(0.8)
+  end
+
+  it 'includes the probability at the threshold' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[2] = 2.to_lf
+    distribution[5] = 5.to_lf
+    distribution[7] = 3.to_lf
+    expect(distribution.threshold_probability(0.5, 10)).to eq(0.8)
+  end
+end
+
+describe Sapor::CombinationsDistribution, '#values' do
+  it 'returns an empty array for an empty distribution' do
+    distribution = Sapor::CombinationsDistribution.new
+    expect(distribution.values).to eq([])
+  end
+
+  it 'returns 1 when a value-combinations pair has been added' do
+    distribution = Sapor::CombinationsDistribution.new
+    distribution[1] = 2
+    expect(distribution.values).to eq([1])
+  end
+end

data/spec/unit/denominators_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+#
+# Statistical Analysis of Polling Results (SAPoR)
+# Copyright (C) 2014 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 'spec_helper'
+
+describe Sapor::DhondtDenominators, '#get' do
+  it 'returns [1, 2, 3, 4, 5] as the five first elements' do
+    denominators = Sapor::DhondtDenominators.get(5).each.to_a
+    expect(denominators).to eq([1, 2, 3, 4, 5])
+  end
+end
+
+describe Sapor::SainteLague14Denominators, '#get' do
+  it 'returns [1.4, 3, 5, 7, 9] as the five first elements' do
+    denominators = Sapor::SainteLague14Denominators.get(5).each.to_a
+    expect(denominators).to eq([1.4, 3, 5, 7, 9])
+  end
+end

data/spec/unit/dichotomies_spec.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+#
+# Statistical Analysis of Polling Results (SAPoR)
+# Copyright (C) 2014 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 'spec_helper'
+
+SAMPLE_RESULTS = { 'Red' => 1, 'Green' => 2, 'Blue' => 3, 'Other' => 1 }
+SAMPLE_POPULATION_SIZE = 1_000_000
+
+describe Sapor::Dichotomies, '#confidence_interval_values' do
+  it 'returns the confidence interval values' do
+    dichotomies = Sapor::Dichotomies.new(SAMPLE_RESULTS,
+                                         SAMPLE_POPULATION_SIZE)
+    expect(dichotomies.confidence_interval_values('Red', 0.95)).to \
+      eq([500_000])
+  end
+
+  it 'returns the non-default confidence interval values' do
+    dichotomies = Sapor::Dichotomies.new(SAMPLE_RESULTS,
+                                         SAMPLE_POPULATION_SIZE)
+    dichotomies.refine
+    expect(dichotomies.confidence_interval_values('Red', 0.9999).sort).to \
+      eq([166_667, 500_000, 833_333])
+  end
+end
+
+describe Sapor::Dichotomies, '#error_estimate' do
+  it 'returns the largest error estimate of the underlying Dichotomy ' \
+     'objects' do
+    dichotomies = Sapor::Dichotomies.new(SAMPLE_RESULTS,
+                                         SAMPLE_POPULATION_SIZE)
+    expect(dichotomies.error_estimate).to eq(1)
+  end
+end
+
+describe Sapor::Dichotomies, '#progress_report' do
+  it 'reports progress as 1 data point by default' do
+    dichotomies = Sapor::Dichotomies.new(SAMPLE_RESULTS,
+                                         SAMPLE_POPULATION_SIZE)
+    expect(dichotomies.progress_report).to eq('Number of data points: 1.')
+  end
+
+  it 'reports progress as 3 data points after the first refinement' do
+    dichotomies = Sapor::Dichotomies.new(SAMPLE_RESULTS,
+                                         SAMPLE_POPULATION_SIZE)
+    dichotomies.refine
+    expect(dichotomies.progress_report).to eq('Number of data points: 3.')
+  end
+end
+
+describe Sapor::Dichotomies, '#report' do
+  it 'produces a report by default for short choice labels' do
+    dichotomies = Sapor::Dichotomies.new(SAMPLE_RESULTS,
+                                         SAMPLE_POPULATION_SIZE)
+    expected_report = 'Most probable fractions and 95% confidence ' \
+                      "intervals:\n" \
+                      "Choice    MPF      CI(95%)\n" \
+                      "Blue     50.0%    0.0%–100.0%\n" \
+                      "Green    50.0%    0.0%–100.0%\n" \
+                      "Red      50.0%    0.0%–100.0%\n" \
+                      'Other    50.0%    0.0%–100.0%'
+    expect(dichotomies.report).to eq(expected_report)
+  end
+
+  it 'produces a report by default for long choice labels' do
+    dichotomies = Sapor::Dichotomies.new({ 'Dark Red' => 1,
+                                           'Light Green' => 2,
+                                           'Medium Blue' => 3, 'Other' => 1 },
+                                         SAMPLE_POPULATION_SIZE)
+    expected_report = 'Most probable fractions and 95% confidence ' \
+                      "intervals:\n" \
+                      "Choice         MPF      CI(95%)\n" \
+                      "Dark Red      50.0%    0.0%–100.0%\n" \
+                      "Light Green   50.0%    0.0%–100.0%\n" \
+                      "Medium Blue   50.0%    0.0%–100.0%\n" \
+                      'Other         50.0%    0.0%–100.0%'
+    expect(dichotomies.report).to eq(expected_report)
+  end
+
+  it 'produces a report after the first refinement' do
+    dichotomies = Sapor::Dichotomies.new(SAMPLE_RESULTS,
+                                         SAMPLE_POPULATION_SIZE)
+    dichotomies.refine
+    expected_report = 'Most probable fractions and 95% confidence ' \
+                      "intervals:\n" \
+                      "Choice    MPF      CI(95%)\n" \
+                      "Blue     50.0%    0.0%–100.0%\n" \
+                      "Green    16.7%    0.0%– 66.7%\n" \
+                      "Red      16.7%    0.0%– 66.7%\n" \
+                      'Other    16.7%    0.0%– 66.7%'
+    expect(dichotomies.report).to eq(expected_report)
+  end
+
+  it 'sorts the choices according to MPV' do
+    dichotomies = Sapor::Dichotomies.new({ 'Red' => 3, 'Green' => 2,
+                                           'Blue' => 1, 'Other' => 1 },
+                                         SAMPLE_POPULATION_SIZE)
+    dichotomies.refine
+    expected_report = 'Most probable fractions and 95% confidence ' \
+                      "intervals:\n" \
+                      "Choice    MPF      CI(95%)\n" \
+                      "Red      50.0%    0.0%–100.0%\n" \
+                      "Blue     16.7%    0.0%– 66.7%\n" \
+                      "Green    16.7%    0.0%– 66.7%\n" \
+                      'Other    16.7%    0.0%– 66.7%'
+    expect(dichotomies.report).to eq(expected_report)
+  end
+
+  it "puts Other on the last line, even if it's listed first and largest" do
+    dichotomies = Sapor::Dichotomies.new({ 'Other' => 4, 'Red' => 1,
+                                           'Green' => 2, 'Blue' => 3 },
+                                         SAMPLE_POPULATION_SIZE)
+    dichotomies.refine
+    expected_report = 'Most probable fractions and 95% confidence ' \
+                      "intervals:\n" \
+                      "Choice    MPF      CI(95%)\n" \
+                      "Blue     16.7%    0.0%– 66.7%\n" \
+                      "Green    16.7%    0.0%– 66.7%\n" \
+                      "Red      16.7%    0.0%– 66.7%\n" \
+                      'Other    50.0%    0.0%– 66.7%'
+    expect(dichotomies.report).to eq(expected_report)
+  end
+
+  it 'includes threshold probabilities when a threshold provided' do
+    dichotomies = Sapor::Dichotomies.new(SAMPLE_RESULTS,
+                                         SAMPLE_POPULATION_SIZE,
+                                         0.15)
+    dichotomies.refine
+    dichotomies.refine
+    expected_report = 'Most probable fractions and 95% confidence ' \
+                      "intervals:\n" \
+                      "Choice    MPF      CI(95%)     P(≥15%)\n" \
+                      "Blue     38.9%   11.1%– 77.8%   99.6%\n" \
+                      "Green    27.8%    0.0%– 66.7%   95.7%\n" \
+                      "Red      16.7%    0.0%– 55.6%   76.1%\n" \
+                      'Other    16.7%    0.0%– 55.6%   76.1%'
+    expect(dichotomies.report).to eq(expected_report)
+  end
+end

data/spec/unit/dichotomy_spec.rb

@@ -0,0 +1,320 @@
+# encoding: utf-8
+#
+# Statistical Analysis of Polling Results (SAPoR)
+# Copyright (C) 2014 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 'spec_helper'
+
+def dichotomy_of_eight
+  Sapor::Dichotomy.new(2, 5, 8)
+end
+
+def dichotomy_of_nine
+  Sapor::Dichotomy.new(2, 5, 9)
+end
+
+def dichotomy_of_thousand
+  Sapor::Dichotomy.new(2, 5, 1000)
+end
+
+def dichotomy_of_nine_hundred_ninety_nine
+  Sapor::Dichotomy.new(2, 5, 999)
+end
+
+describe Sapor::Dichotomy, '#new' do
+  it 'creates an array with a value at 50% of the population size' do
+    expect(dichotomy_of_eight.values).to eq([4])
+  end
+
+  it 'creates an array with a value at 50% of the population size' \
+     ' (rounding)' do
+    expect(dichotomy_of_nine.values).to eq([4])
+  end
+
+  it 'creates an array with a combination for 50% of the population size' do
+    expect(dichotomy_of_eight.combinations(4)).to eq(24.to_lf)
+  end
+end
+
+describe Sapor::Dichotomy, '#confidence_interval' do
+  it 'returns [0%, 100%] after new for default level 95%' do
+    expect(dichotomy_of_eight.confidence_interval).to eq([0.0, 1.0])
+  end
+
+  it 'returns the default 95% confidence interval after one refinement' do
+    dichotomy = Sapor::Dichotomy.new(20, 50, 80)
+    dichotomy.refine
+    expect(dichotomy.confidence_interval).to eq([0.3375, 0.6625])
+  end
+
+  it 'returns the default 95% confidence interval after three refinements' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.confidence_interval).to eq([0.112, 0.777])
+  end
+
+  it 'returns the 80% confidence interval after three refinements' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.confidence_interval(0.8)).to eq([0.186, 0.666])
+  end
+end
+
+describe Sapor::Dichotomy, '#error_estimate' do
+  it 'is 0 when population size is reached' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.error_estimate).to eq(0)
+  end
+
+  it 'is at least the resolution (no refinement)' do
+    dichotomy = dichotomy_of_eight
+    expect(dichotomy.error_estimate).to eq(1.0)
+  end
+
+  it 'is at least the resolution (one refinement)' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    expect(dichotomy.error_estimate).to eq(1.to_f / 3)
+  end
+end
+
+describe Sapor::Dichotomy, '#most_probable_fraction' do
+  it 'returns the fraction of the single value after new' do
+    expect(dichotomy_of_eight.most_probable_fraction).to eq(0.5)
+  end
+
+  it 'returns the one probable value after one refinement' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    expect(dichotomy.most_probable_fraction).to eq(0.5)
+  end
+
+  it 'returns the new most probable value after two refinements' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.most_probable_fraction).to eq(0.375)
+  end
+end
+
+describe Sapor::Dichotomy, '#most_probable_value' do
+  it 'returns the single value after new' do
+    expect(dichotomy_of_eight.most_probable_value).to eq(4)
+  end
+
+  it 'returns the one probable value after one refinement' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    expect(dichotomy.most_probable_value).to eq(4)
+  end
+
+  it 'returns the new most probable value after two refinements' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.most_probable_value).to eq(3)
+  end
+end
+
+describe Sapor::Dichotomy, '#refine' do
+  it 'adds values after one refinement (power of three)' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([1, 4, 7])
+  end
+
+  it 'adds values after one refinement (small population)' do
+    dichotomy = dichotomy_of_nine
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([1, 4, 7])
+  end
+
+  it 'adds values after one refinement (large population)' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([167, 500, 833])
+  end
+
+  it 'adds values after two refinements (power of three)' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8])
+  end
+
+  it 'adds values after two refinements (small population)' do
+    dichotomy = dichotomy_of_nine
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8])
+  end
+
+  it 'adds values after two refinements (small population)' do
+    dichotomy = Sapor::Dichotomy.new(2, 5, 60)
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([3, 10, 17, 23, 30, 37, 43, 50, 57])
+  end
+
+  it 'adds values after two refinements (large population)' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([56, 167, 278, 389, 500, 611, 722, 833,
+                                         944])
+  end
+
+  it "doesn't add values when population size is reached" do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8])
+  end
+
+  it 'fills up the values when population size is reached' do
+    dichotomy = dichotomy_of_nine
+    dichotomy.refine
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+  end
+
+  it 'fills up the values when population size is reached' do
+    dichotomy = Sapor::Dichotomy.new(2, 5, 11)
+    dichotomy.refine
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.values.sort).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
+  end
+
+  it 'adds combinations after a refinement' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    expect(dichotomy.combinations(167)).to eq(1_330_493_216_416.to_lf)
+    expect(dichotomy.combinations(833)).to eq(264_177_353_440.to_lf)
+  end
+
+  it 'adds combinations of zero for impossible values' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    expect(dichotomy.combinations(1)).to eq(0.to_lf)
+    expect(dichotomy.combinations(7)).to eq(0.to_lf)
+  end
+end
+
+describe Sapor::Dichotomy, '#threshold_probability' do
+  it 'returns 100% after new for a 50% threshold' do
+    expect(dichotomy_of_thousand.threshold_probability(0.5)).to eq(1)
+  end
+
+  it 'returns 0% after new for a 51% threshold' do
+    expect(dichotomy_of_thousand.threshold_probability(0.51)).to eq(0)
+  end
+
+  it 'returns 100% for a 5% threshold after one refinement' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    expect(dichotomy.threshold_probability(0.05)).to eq(1)
+  end
+
+  it 'returns 68% (after rounding) for a 50% threshold after one refinement' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    expect(dichotomy.threshold_probability(0.5).round(2)).to eq(0.68)
+  end
+
+  it 'returns 0% for a 95% threshold after one refinement' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    expect(dichotomy.threshold_probability(0.95)).to eq(0)
+  end
+end
+
+describe Sapor::Dichotomy, '#value_confidence_interval' do
+  it 'returns [0, population_size] values after new for default level 95%' do
+    expect(dichotomy_of_eight.value_confidence_interval).to eq([0, 8])
+  end
+
+  it 'returns [0, population_size] values after new for level 80%' do
+    expect(dichotomy_of_eight.value_confidence_interval(0.8)).to eq([0, 8])
+  end
+
+  it 'returns the value confidence interval after one refinement' do
+    dichotomy = Sapor::Dichotomy.new(20, 50, 80)
+    dichotomy.refine
+    expect(dichotomy.value_confidence_interval).to eq([27, 53])
+  end
+
+  it 'returns the value confidence interval after full refinement' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.value_confidence_interval).to eq([2, 5])
+  end
+
+  it 'returns the 80% value confidence interval after full refinement' do
+    dichotomy = dichotomy_of_eight
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.value_confidence_interval(0.8)).to eq([2, 5])
+  end
+
+  it 'returns the value confidence interval after two refinements' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.value_confidence_interval).to eq([112, 777])
+  end
+
+  it 'returns the 80% value confidence interval after two refinements' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.value_confidence_interval(0.8)).to eq([112, 666])
+  end
+
+  it 'returns the value confidence interval after three refinements' do
+    dichotomy = dichotomy_of_thousand
+    dichotomy.refine
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.value_confidence_interval).to eq([112, 777])
+  end
+
+  it 'can return a confidence interval starting at 0 after refinements' do
+    dichotomy = Sapor::Dichotomy.new(0, 5, 1000)
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.value_confidence_interval).to eq([0, 555])
+  end
+
+  it 'can return a confidence interval ending at population size after ' \
+     'refinements' do
+    dichotomy = Sapor::Dichotomy.new(5, 5, 1000)
+    dichotomy.refine
+    dichotomy.refine
+    expect(dichotomy.value_confidence_interval).to eq([445, 1000])
+  end
+end