observance 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7dfc295009d53d249c379697a871e38abd6f3ec1
-  data.tar.gz: 1abc3656a6c554a43402e77f204e643d3bbe5369
+  metadata.gz: 553f83a148f0ff71cd4f7e0172afc68fc359d5ab
+  data.tar.gz: c56c3391312d58cf455d69c1121cf079aaa5ef8b
 SHA512:
-  metadata.gz: d5cb644af3b4d4173d01d7ec6f0bf5fdc1368b54f10fc12707f9723f9e4247978f9a367cf5eff62c987d03d5d3daed30299fac4f57716f1e2550a7504a182136
-  data.tar.gz: b76a12662b91601b5b0e41a2811b2ea50ce5c3e6d924af4d97a9279691c4a491deebddbca01c034c4451e88449de873749a06e262195ffbf3688a603ab6ff7a2
+  metadata.gz: 3083ccf959eec5e7bb8f1e4e84b25f2e18308c0066abd1e79eaf447ec0cb33b780f48b5b896e04e160353c98625c6cc914891acfb5758ccf4040ae72ee4f636c
+  data.tar.gz: 09894761a0ca773960edb616d7d03b19be6ccef4032c9c19cc7f9b09310682c17066fed76022024e784eac43ca08b507bb64d6a3c463439fffe2add4d8cf9050

data/README.md

@@ -1,61 +1,124 @@
 # Observance
 
-Given multiple observations returns the most likely.
+Given a collection of observations it returns the most likely. An observation is anything that responds to `to_a` Array or that responds to `to_h`.
 
-Imagine a person flashing at a distance a card 
-displaying a number from 1 to 10. Let us say five people
-are observing this remote scene and note their observations during 4 rounds.
+As an example imagine a person flashing at a distance a card
+displaying a number from 1 to 10. If five people are observing
+this remote scene and note their observations during 4 rounds we have
 
+```ruby
 observer_1 = {first: 8, second: 6, third: 1, fourth: 4}
 observer_2 = {first: 8, second: 6, third: 7, fourth: 4}
 observer_3 = {first: 8, second: 9, third: 7, fourth: 4}
 observer_4 = {first: 8, second: 9, third: 2, fourth: 8}
 observer_5 = {first: 0, second: 2, third: 0, fourth: 1}
+```
+
+The probable outcome seems to be `8-(6 or 9)-7-4`. So the best observation
+would either be `8-6-7-4` or `8-9-7-4`.
+
+Using `Observance` we determine the most likely observation(s) by doing:
+
+```ruby
+observations = Observance.run(observer_1, observer_2, observer_3,
+                                observer_4, observer_5)
 
-The probable outcome seems to be 8-(6 or 9)-7-4. So the probable observation
-would either be 8-6-7-4 or 8-9-7-4.
+observations[0].rating #=> 0.55
+observations[0].object #=> observer_2
+
+observations[1].rating #=> 0.55
+observations[1].object #=> observer_3
+
+observations[2].rating #=> 0.5
+observations[3].rating #=> 0.4
+observations[4].rating #=> 0.2
+```
+
+As expected it gives us that `observer_2` and `observer_3` are equally the most likely to have happened.
 
 ## Installation
 
 Add `gem 'observance'` to your Gemfile or run `gem install observance`
 
+## Testing
+
+This gem uses minitest. Just run `bundle exec rake` to test.
+
+## Features
+
+* Handle observations of **different sizes** (although makes less sense)
+* Observations can be **JSON documents** since `Observance` handles nested hashes
+* Filter which set of keys to run `Observance` on
+
 ## Usage
 
-This gem runs on given sets of observations. An observation is anything
-that responds to `to_h` or `to_hash`.
+### Observance input
+
+`Observance` needs as input collections of observations. An observation is anything
+that responds to `to_a` or `to_h`.
+
+For instance Hashes or Arrays:
 
 ```ruby
 o1 = {first_toss: 'head', second_toss: 'tail', third_toss: 'tail'}
 o2 = {first_toss: 'head', second_toss: 'tail', third_toss: 'tail'}
 o3 = {first_toss: 'tail', second_toss: 'tail', third_toss: 'tail'}
 
-Observance.observed(o1, o2, o3)
+Observance.run(o1, o2, o3)
+
+o1 = ['head', 'tail', 'tail']
+o2 = ['head', 'tail', 'tail']
+o3 = ['tail', 'tail', 'tail']
+
+Observance.run(o1, o2, o3)
+
 ```
 
-Since a observation object is anything that responds to `to_h` or `to_hash`, observations
-can be a Hash, a parsed JSON, or a slightly modified Struct
+Since a observation object is anything that responds to `to_a` or `to_h`, it
+can also be a parsed JSON, or a slightly modified Struct as follows:
 
 ```ruby
 # Observation as a slightly modified Struct
-Scores = Struct.new(:period_1, :period_2, :period_3, period_4) do
+Scores = Struct.new(:period_1, :period_2, :period_3, :period_4) do
   def to_h
     Hash[members.zip(to_a)]
   end
 end
 
 tom_observations = Scores.new(5, 6, 7, 4)
-jane_observations = Scores.new(5, 6, 7, 4)
+jane_observations = Scores.new(5, 5, 7, 4)
+bill_observations = Scores.new(5, 6, 6, 4)
 
-Observance.observed(tom_observations, jane_observations)
+results = Observance.run(tom_observations, jane_observations, bill_observations)
+results.first #=> Tom sample is the most likely with a rating of 0.8333
 ```
 
-The result returned is an ordered collection of Observance::Observed objects
+### Observance output
 
-```ruby
-results = Observance.observed(o1, o2, o3, o4, o5)
-observed_1, observed_2, _ = results
+Running Observance, it returns a sorted Array of `Observance::Observation` objects. Each `Observance::Observation` contains the original observation object (usually a hash) along with a **rating** (a float number between 0 and 1).
+
+**The higher the rating the better the observation.**
 
-observed_1.factor = 0.7515
-observed_1.object == 01
+The results **are sorted by rating** - with the highest rating (most likely) being the first.
 
+## Simple example
+
+5 people observe a coin being tossed 5 times. Each sends their observations as an Array
+
+```ruby
+o1 = ['head', 'tail', 'tail', 'head', 'tail']
+o2 = ['tail', 'tail', 'tail', 'head', 'tail']
+o3 = ['head', 'head', 'tail', 'head', 'tail']
+o4 = ['head', 'head', 'head', 'head', 'tail']
+o5 = ['head', 'tail', 'tail', 'tail', 'head']
+
+results = Observance.run(o1, o2, o3, o4, o5)
+results.class # => Array
+
+puts results
+#<struct Observance::Observation rating=0.76, object=["head", "tail", "tail", "head", "tail"], index=0>
+#<struct Observance::Observation rating=0.72, object=["head", "head", "tail", "head", "tail"], index=2>
+#<struct Observance::Observation rating=0.64, object=["tail", "tail", "tail", "head", "tail"], index=1>
+#<struct Observance::Observation rating=0.6, object=["head", "head", "head", "head", "tail"], index=3>
+#<struct Observance::Observation rating=0.52, object=["head", "tail", "tail", "tail", "head"], index=4>
 ```

data/Rakefile

@@ -2,6 +2,7 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
+  t.pattern = "test/**/*_test.rb"
   t.libs << "test"
 end
 

data/lib/observance.rb

@@ -1,5 +1,68 @@
-require "observance/version"
+require 'observance/version'
 
 module Observance
-  # Your code goes here...
+
+  Observation = Struct.new(:rating, :object, :index) do
+    include Comparable
+
+    def <=>(other)
+      return nil unless other.is_a? self.class
+      if other.rating == self.rating
+        self.index <=> other.index
+      else
+        other.rating <=> self.rating
+      end
+    end
+  end
+
+  def self.run(*observations)
+    obs = if observations.first.is_a? Array
+            wrapped_in_hashes(observations)
+          elsif observations.first.respond_to? :to_h
+            observations.map(&:to_h)
+          else
+            raise "Observations need to be Array or respond to 'to_h'"
+          end
+    obs.each_with_index.map do |c, index|
+      rating = (obs.inject(0) do |acc, o|
+        acc = acc + c.similarity_to(o)
+      end).fdiv(obs.size)
+      Observation.new(rating.round(4), observations[index], index)
+    end.sort
+  end
+
+  private
+
+  def self.wrapped_in_hashes(observations)
+    observations.map do |o| 
+      Hash[(0...o.size).zip(o)]
+    end
+  end
 end
+
+class Hash
+  # Returns a rating f between 0 and 1 that indicates
+  # the similarity rating of self to other
+  #
+  # Calculates the number of keys with the same values
+  # then divide the result by the number of keys
+  def similarity_to(other)
+    smaller_one, bigger_one = [self, other].sort_by(&:size)
+    diff_size = bigger_one.size - smaller_one.size
+
+    ratio = bigger_one.size + diff_size
+
+    sum = 0
+    bigger_one.each_pair do |k, v|
+      (sum = sum + 1) if v == smaller_one[k]
+    end
+    r1 = sum.fdiv(bigger_one.size)
+
+    sum2 = 0
+    smaller_one.each_pair do |k, v|
+      (sum2= sum2 + 1) if v == bigger_one[k]
+    end
+    r2 = (sum2).fdiv(ratio)
+    (r1 + r2).fdiv(2)
+  end
+end 

data/lib/observance/version.rb

@@ -1,3 +1,3 @@
 module Observance
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/observance.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest"
+  spec.add_development_dependency "pry"
 end

data/test/hash_extensions_test.rb

@@ -0,0 +1,56 @@
+require 'minitest_helper'
+
+class TestHashExtension < MiniTest::Test
+
+  def test_similarity_in_same_size_hashes
+    h = {one: 1, two: 2, three: 3, four: 4, five: 5, 
+         six: 6, seven: 7, eight: 8, nine: 9, ten: 10}
+
+    assert_equal 1, h.similarity_to(h)
+    assert_equal 0.9, h.similarity_to(h.merge(one: 0))
+    assert_equal 0.8, h.similarity_to(h.merge(one: 0, two: 0))
+    assert_equal 0.7, h.similarity_to(h.merge(one: 0, two: 0, three: 0))
+    assert_equal 0.6, h.similarity_to(h.merge(one: 0, two: 0, three: 0, four: 0))
+    assert_equal 0.5, h.similarity_to(h.merge(one: 0, two: 0, three: 0, four: 0, five: 0))
+    assert_equal 0.4, h.similarity_to(h.merge(one: 0, two: 0, three: 0, four: 0, five: 0,
+                                              six: 0))
+    assert_equal 0.3, h.similarity_to(h.merge(one: 0, two: 0, three: 0, four: 0, five: 0,
+                                              six: 0, seven: 0))
+    assert_equal 0.2, h.similarity_to(h.merge(one: 0, two: 0, three: 0, four: 0, five: 0,
+                                              six: 0, seven: 0, eight: 0))
+    assert_equal 0.1, h.similarity_to(h.merge(one: 0, two: 0, three: 0, four: 0, five: 0,
+                                              six: 0, seven: 0, eight: 0, nine: 0))
+    assert_equal 0.0, h.similarity_to(h.merge(one: 0, two: 0, three: 0, four: 0, five: 0,
+                                              six: 0, seven: 0, eight: 0, nine: 0, ten: 0))
+  end
+
+  def test_similarity_in_different_size_hashes
+    h = {one: 1, two: 2, three: 3, four: 4} 
+
+    assert_in_delta 0.733, h.similarity_to({one: 1, two: 2, three: 3, four: 4, five: 5})
+    assert_equal 0.675, h.similarity_to({one: 1, two: 2, three: 3})
+    assert_in_delta 0.416, h.similarity_to({one: 1, two: 2})
+    assert_in_delta 0.208, h.similarity_to({one: 0, two: 2})
+    assert_in_delta 0.183, h.similarity_to({one: 0, two: 0, three: 0, four: 4, five: 5})
+    assert_equal 0.0, h.similarity_to({one: 0, two: 0, three: 0, four: 0, five: 5})
+  end
+
+  def test_same_size_has_better_similarity_than_different_size
+    h = {one: 1, two: 2, three: 3, four: 4} 
+
+    assert h.similarity_to({one: 1, two: 2, three: 3}) <
+            h.similarity_to(one: 1, two: 2, three: 3, four: 0)
+  end
+
+  def test_symmetry_of_similarity_operation
+    h = {one: 1, two: 2, three: 3, four: 4}
+    o = {one: 2, two: 1, three: 3, four: 5}
+
+    assert_equal h.similarity_to(o), o.similarity_to(h)
+
+    h = {one: 1, two: 2, three: 3, four: 4}
+    o = {one: 1, two: 2, three: 3, four: 4, five: 5}
+
+    assert_equal h.similarity_to(o), o.similarity_to(h)
+  end
+end

data/test/observance_test.rb

@@ -0,0 +1,85 @@
+require 'minitest_helper'
+
+class TestObservance < MiniTest::Test
+  def test_returns_ordered_observation_from_same_size_hashes
+    o1 = {one: 1, two: 2, three: 3, four: 4}
+    o2 = {one: 1, two: 2, three: 3, four: 4}
+    o3 = {one: 1, two: 2, three: 3, four: 0}
+    o4 = {one: 1, two: 2, three: 0, four: 4}
+    o5 = {one: 1, two: 2, three: 0, four: 0}
+    o6 = {one: 1, two: 0, three: 0, four: 0}
+    o7 = {one: 0, two: 0, three: 0, four: 0}
+
+    observations = Observance.run(o1, o2, o3, o4, o5, o6, o7)
+
+    assert_equal o5, observations[0].object 
+    assert_equal o3, observations[1].object 
+    assert_equal o4, observations[2].object 
+    assert_equal o1, observations[3].object 
+    assert_equal o2, observations[4].object 
+    assert_equal o6, observations[5].object 
+    assert_equal o7, observations[6].object 
+
+    assert_equal 0.6786, observations[0].rating 
+    assert_equal 0.6429, observations[1].rating 
+    assert_equal 0.6429, observations[2].rating 
+    assert_equal 0.6071, observations[3].rating 
+    assert_equal 0.6071, observations[4].rating 
+    assert_equal 0.5714, observations[5].rating 
+    assert_equal 0.3929, observations[6].rating 
+  end
+
+  def test_returns_ordered_observation_from_different_size_hashes
+    o1 = {one: 1, two: 2, three: 3, four: 4, five: 5}
+    o2 = {one: 1, two: 2, three: 3, four: 4}
+    o3 = {zero: 0, one: 1, two: 2, three: 3, four: 0}
+    o4 = {one: 1, two: 2, three: 0, four: 4}
+    o5 = {one: 1, two: 2, three: 0, four: 0, ten: 10, eleven: 11}
+    o6 = {one: 1, two: 0}
+    o7 = {one: 0, two: 0, three: 0}
+
+    observations = Observance.run(o1, o2, o3, o4, o5, o6, o7)
+
+    assert_equal o4, observations[0].object 
+    assert_equal o2, observations[1].object 
+    assert_equal o1, observations[2].object 
+    assert_equal o3, observations[3].object 
+    assert_equal o5, observations[4].object 
+    assert_equal o6, observations[5].object 
+    assert_equal o7, observations[6].object 
+
+    assert_equal 0.5054, observations[0].rating 
+    assert_equal 0.5048, observations[1].rating 
+    assert_equal 0.4793, observations[2].rating 
+    assert_equal 0.4491, observations[3].rating 
+    assert_equal 0.3965, observations[4].rating 
+    assert_equal 0.3095, observations[5].rating 
+  end
+
+  def test_returns_ordered_observation_from_same_size_arrays
+    o1 = [1, 2, 3, 4]
+    o2 = [1, 2, 3, 4]
+    o3 = [1, 2, 3, 0]
+    o4 = [1, 2, 0, 4]
+    o5 = [1, 2, 0, 0]
+    o6 = [1, 0, 0, 0]
+    o7 = [0, 0, 0, 0]
+
+    observations = Observance.run(o1, o2, o3, o4, o5, o6, o7)
+
+    assert_equal o5, observations[0].object 
+    assert_equal o3, observations[1].object 
+    assert_equal o4, observations[2].object 
+    assert_equal o1, observations[3].object 
+    assert_equal o2, observations[4].object 
+    assert_equal o6, observations[5].object 
+    assert_equal o7, observations[6].object 
+
+    assert_equal 0.6786, observations[0].rating 
+    assert_equal 0.6429, observations[1].rating 
+    assert_equal 0.6429, observations[2].rating 
+    assert_equal 0.6071, observations[3].rating 
+    assert_equal 0.6071, observations[4].rating 
+    assert_equal 0.5714, observations[5].rating 
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: observance
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - simcap
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Returns the most likely observation given multiple observations
 email:
 - simcap@fastmail.com
@@ -60,7 +74,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -68,8 +81,9 @@ files:
 - lib/observance.rb
 - lib/observance/version.rb
 - observance.gemspec
+- test/hash_extensions_test.rb
 - test/minitest_helper.rb
-- test/test_observance.rb
+- test/observance_test.rb
 homepage: ''
 licenses:
 - MIT
@@ -95,5 +109,6 @@ signing_key:
 specification_version: 4
 summary: Returns the most likely observation given multiple observations
 test_files:
+- test/hash_extensions_test.rb
 - test/minitest_helper.rb
-- test/test_observance.rb
+- test/observance_test.rb

data/.travis.yml

@@ -1,3 +0,0 @@
-language: ruby
-rvm:
-  - 2.1.5

data/test/test_observance.rb

@@ -1,11 +0,0 @@
-require 'minitest_helper'
-
-class TestObservance < MiniTest::Unit::TestCase
-  def test_that_it_has_a_version_number
-    refute_nil ::Observance::VERSION
-  end
-
-  def test_it_does_something_useful
-    assert false
-  end
-end