Personal Solutions to David Barber’s Bayesian Reasoning and Machine Learning (Chapter 1)

pot(knife).variables=[knife,butler,maid];

pot(knife).table(used, notmurderer, notmurderer)=0.3;
pot(knife).table(used, notmurderer, murderer)   =0.04;
pot(knife).table(used, murderer,    notmurderer)=0.64;
pot(knife).table(used, murderer,    murderer)   =0.0;

    function demoSoftXOR
    a=1; b=2; c=3; % variables
    on=1; off=2; % states

    % The following definitions of variable are not necessary for computation,
    % but are useful for displaying table entries:
    variable(a).name='a'; variable(a).domain = {'on','off'};
    variable(b).name='b'; variable(b).domain ={'on','off'};
    variable(c).name='c'; variable(c).domain={'on','off'};

    % Three potentials since p(a,b,c)=p(c|a,b)p(a)p(b).
    % potential numbering is arbitary
    pot(a).variables=a;
    pot(a).table(on)=0.65;
    pot(a).table(off)=0.35;

    pot(b).variables=b;
    pot(b).table(on)=0.77;
    pot(b).table(off)=0.23;

    pot(c).variables=[c,a,b]; % define array below using this variable order
    pot(c).table(on, off, off) =0.1;
    pot(c).table(on, off, on)  =0.99;
    pot(c).table(on, on, off)  =0.8;
    pot(c).table(on, on, on)   =0.25;
    pot(c).table(off,:,:)=1-pot(c).table(on,:,:); % due to normalisation

    jointpot = multpots(pot([a b c])); % joint distribution

    drawNet(dag(pot),variable);
    disp('p(a|c=0):')
    disptable(condpot(setpot(jointpot,c,off),a),variable);

function demoTwoDice
%DEMOCLOUSEAU inspector clouseau example
s1=1; s2=2; t=3; % Variable order is arbitary

% define states, starting from 1.
one=1; two=2; three=3; four=4; five=5; six=6;
seven=7; eight=7; nine=7; ten=7; eleven=7; twelve=7;

% The following definitions of variable are not necessary for computation,
% but are useful for displaying table entries:
variable(s1).name='s1';
variable(s1).domain = {'one',
  'two',
  'three',
  'four',
  'five',
  'six'};
variable(s2).name='s2';
variable(s2).domain ={'one','two','three', 'four', 'five', 'six'};

variable(t).name='t';
variable(t).domain ={'two', \
  'three', \
  'four', \
  'five', \
  'six', \
  'seven', \
  'eight', \
  'nine', \
  'ten', \
  'eleven', \
  'twelve' };

% Three potentials since p(s1,s2,t)=p(t|s1,s2)p(s1)p(s2).
% potential numbering is arbitary
pot(s1).variables=s1;
pot(s1).table(one)=0.16666;
pot(s1).table(two)=0.16666;
pot(s1).table(three)=0.16666;
pot(s1).table(four)=0.16666;
pot(s1).table(five)=0.16666;
pot(s1).table(six)=0.16666;

pot(s2).variables=s2;
pot(s2).table(one)=0.16666;
pot(s2).table(two)=0.16666;
pot(s2).table(three)=0.16666;
pot(s2).table(four)=0.16666;
pot(s2).table(five)=0.16666;
pot(s2).table(six)=0.16666;

pot(t).variables=[t,s1,s2]; % define array below using this variable order
pot(t).table(2 , 1 , 1)=1;

pot(t).table(3 , 1 , 2)=1;
pot(t).table(3 , 2 , 1)=1;

pot(t).table(4 , 1 , 3)=1;
pot(t).table(4 , 3 , 1)=1;
pot(t).table(4 , 2 , 2)=1;

pot(t).table(5 , 1 , 4)=1;
pot(t).table(5 , 4 , 1)=1;
pot(t).table(5 , 2 , 3)=1;
pot(t).table(5 , 3 , 2)=1;

pot(t).table(6 , 1 , 5)=1;
pot(t).table(6 , 5 , 1)=1;
pot(t).table(6 , 2 , 4)=1;
pot(t).table(6 , 4 , 2)=1;
pot(t).table(6 , 3 , 3)=1;

pot(t).table(7 , 1 , 6)=1;
pot(t).table(7 , 6 , 1)=1;
pot(t).table(7 , 2 , 5)=1;
pot(t).table(7 , 5 , 2)=1;
pot(t).table(7 , 3 , 4)=1;
pot(t).table(7 , 4 , 3)=1;

pot(t).table(8 , 2 , 6)=1;
pot(t).table(8 , 6 , 2)=1;
pot(t).table(8 , 3 , 5)=1;
pot(t).table(8 , 5 , 3)=1;
pot(t).table(8 , 4 , 4)=1;

pot(t).table(9 , 3 , 6)=1;
pot(t).table(9 , 6 , 3)=1;
pot(t).table(9 , 4 , 5)=1;
pot(t).table(9 , 5 , 4)=1;

pot(t).table(10, 6, 4)=1;
pot(t).table(10, 4, 6)=1;
pot(t).table(10, 5, 5)=1;

pot(t).table(11, 6, 5)=1;
pot(t).table(11, 5, 6)=1;

pot(t).table(12, 6, 6)=1;

jointpot = multpots(pot([s1 s2 t])); % joint distribution

drawNet(dag(pot),variable);
disp('p(s1,s2|t=9):')
disptable(condpot(setpot(jointpot,t,9),[s1,s2]),variable);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
require 'spec_helper'

describe Psychometry do
  describe 'when there are five pairs to be matched' do
    describe '#absolute_frequencies_of_matches' do
      it 'should return an array of absolute frequencies' do
        # 0 matches occurs 44 times, 1 match occurs 45 times, etc.
        psychometry = Psychometry.new

        abs_freq = [44, 45, 20, 10, 0, 1]
        expect(psychometry.absolute_frequencies_of_matches).
          to eq abs_freq
      end
    end

    describe '#permutations' do
      before {@psychometry = Psychometry.new}

      it 'should include ABCDE, EBACD' do
        expect( @psychometry.permutations).
          to include(['A', 'B', 'C', 'D', 'E'])
        expect( @psychometry.permutations).
          to include(['E', 'B', 'A', 'C', 'D'])
      end

      it 'should not include AAAAA' do
        expect( @psychometry.permutations).
          not_to include(['A', 'A', 'A', 'A', 'A'])
      end
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
class Psychometry
  def initialize
    @num_pairs = 5
  end

  def absolute_frequencies_of_matches
    permutations.inject(init_hash) do |accum, permutation|
      accum[num_matches_in_one(permutation)] =
        accum[num_matches_in_one(permutation)] + 1
      accum
    end
  end

  def permutations
    combinations.inject([]) do |accum, combination|
      permutation?(combination) ? (accum << combination) : accum
    end
  end

  private

  def num_matches
    permutations.inject(0) do |accum, permutation|
      accum += num_matches_in_one(permutation)
    end
  end

  def num_matches_in_one(permutation)
    (0..@num_pairs-1).inject(0) do |accum_2, index|
      if permutation[index] == characters[index]
        accum_2 += 1
      else
        accum_2
      end
    end
  end

  def init_hash
    (0..@num_pairs).inject([]) { |accum, val| accum << 0 }
  end

  def combinations
    characters.inject([]) do |accum_1, char_1|
      accum_1 | characters.inject([]) do |accum_2, char_2|
        accum_2 | characters.inject([]) do |accum_3, char_3|
          accum_3 | characters.inject([]) do |accum_4, char_4|
            accum_4 | characters.map do |char_5|
              [char_1, char_2, char_3, char_4, char_5]
            end
          end
        end
      end
    end
  end

  def permutation?(combination)
    combination.uniq.length == combination.length
  end

  def characters
    ('A'..'Z').to_a[0..@num_pairs-1]
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
require 'spec_helper'

describe Pizza4U do
  describe '#unique_combinations' do
    it 'should not return any duplicates' do
      pizza_4_u = Pizza4U.new
      uniq_combs = pizza_4_u.unique_combinations

      orig = ['A', 'A', 'A', 'A', 'A', 'A', 'B']
      rearranged_1 = ['A', 'A', 'A', 'A', 'A', 'B', 'A']
      rearranged_2 = ['A', 'B', 'A', 'A', 'A', 'A', 'A']

      orig_1 = ['A', 'A', 'A', 'A', 'A', 'B', 'B']
      rearranged_3 = ['A', 'B', 'A', 'B', 'A', 'A', 'A']
      rearranged_4 = ['B', 'B', 'A', 'A', 'A', 'A', 'A']

      orig_2 = [ 'B', 'B', 'D', 'D', 'D', 'D', 'D']

      # should not be included because there are only four
      # pizzas to choose from, not 5.
      orig_3 = [ 'E','E','E','E','E','E','E' ]


      expect(uniq_combs).to include(orig)
      expect(uniq_combs).to include(orig_1)
      expect(uniq_combs).to include(orig_2)
      expect(uniq_combs).not_to include(orig_3)
      expect(uniq_combs).not_to include(rearranged_1)
      expect(uniq_combs).not_to include(rearranged_2)
      expect(uniq_combs).not_to include(rearranged_3)
      expect(uniq_combs).not_to include(rearranged_4)
      expect(uniq_combs.count).to eq 120
    end
  end

  describe '#accuracy(num_times)' do
    it 'picks a random combination of pizzas (ordered by people) and compares it with another randomly-picked combination of pizzas (picked by the chef) and gives us a score' do
      pizza_4_u = Pizza4U.new
      accuracy = pizza_4_u.accuracy(1000000)

      expect(accuracy).to eq 1/120.0
    end
  end

  describe '#unique_absolute_freqs' do
    it 'should return a dictionary with unique combinations as keys and absolute freqs as values' do

      pizza_4_u = Pizza4U.new
      unique_absolute_freqs = pizza_4_u.unique_absolute_freqs

      total_count =  unique_absolute_freqs.inject(0){|accum,(k,v)| accum = accum + v; accum}
      expect(total_count).to eq 16384
      expect(unique_absolute_freqs['AAAAAAA']).to be 1
      expect(unique_absolute_freqs['AAAAAAB']).to be 7
    end
  end

  describe '#prob_correct' do
    it 'gives us the chance that the chef was correct' do
      pizza_4_u = Pizza4U.new
      expect(pizza_4_u.prob_correct.round(3)).to eq 0.018383.round(3)
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
require 'utils'

class Pizza4U
  attr_reader :combinations, :unique_combinations, :combinations_size, :unique_absolute_freqs

  def initialize
    @utils = Utils.new(4)
    @combinations = @utils.combinations(7)
    @unique_combinations = combinations.map {|combination| combination.sort}.uniq

    @combinations_size = combinations.count
    @unique_absolute_freqs = unique_combinations.inject({}) do |accum, uniq_combo|
      accum[uniq_combo.join] = combinations.select{|combination| same_unique_combo(combination, uniq_combo)}.count
      accum
    end
  end

  def accuracy(num_times)
    score(num_times) / num_times.to_f
  end

  def prob_correct
    corrects_of_joint_distribution.inject(0) do |accum, hash|
      accum = accum + hash[:posterior_prob]
      accum
    end
  end

  private

  def corrects_of_joint_distribution
    joint_distribution.select{|item| item[:correct] == true}
  end

  def joint_distribution
    unique_absolute_freqs.inject([]) do |accum_1, (chef_k,chef_v)|
      accum_1 + unique_absolute_freqs.inject([]) do |accum_2, (customers_k,customers_v)|
        posterior_prob = chef_v / combinations_size.to_f * customers_v / combinations_size.to_f
        hash = { correct: false, posterior_prob: posterior_prob}

        if chef_k == customers_k
          hash[:correct] = true
        end

        accum_2 << hash
      end
    end
  end

  def score(num_times)
    r = Random.new

    (0..num_times-1).inject(0) do |accum, count|
      customers_pick = pick(r)
      chefs_pick = pick(r)

      if same_unique_combo(customers_pick, chefs_pick)
        accum = accum + 1
      else
        accum
      end
    end
  end

  def same_unique_combo(pick1, pick2)
    pick1.sort == pick2.sort
  end

  def pick(r)
    pick_index = r.rand * combinations.length - 1
    combinations[pick_index]
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Utils
  def initialize(num_pairs)
    @num_pairs = num_pairs
  end

  def combinations(num_iteration)
    combine(characters, num_iteration)
  end

  def combine(accum, num_iteration)
    return accum if num_iteration <= 1

    new_accum = characters.inject([]) do |accum_1, char|
      accum_1 | accum.map do |item|
        [char, item].flatten
      end
    end

    combine(new_accum, num_iteration - 1)
  end

  def characters
    ('A'..'Z').to_a[0..@num_pairs-1]
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
require 'spec_helper'

describe Utils do
  describe '#combinations' do
    it 'should return the right amount of items' do
      num_items_to_choose_from = 4
      num_times_to_combine = 7
      utils = Utils.new(num_items_to_choose_from)
      combinations = utils.combinations(num_times_to_combine)
      expect(combinations.count).to eq 16384
      expect(combinations).to include(['A', 'A', 'A', 'A', 'A', 'A', 'A'])
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
module Battleship
  class Board
    attr_reader :table

    def initialize(init_hash)
      @misses = init_hash[:misses]
      @ships = init_hash[:ships]
      @table = Battleship::Table.new(row_length:row_length,
                                     col_length: col_length,
                                     misses: @misses,
                                     ships: @ships)
      # table should listen to changes in ship status
      # if hit, then recalculate frequencies...
      @table.recalculate_abs_freq!
    end

    def miss?(point)
      @misses.select {|miss| miss.same_as?(point) }.count >= 1
    end

    def row_length
      10
    end

    def col_length
      10
    end

    def best_targets
      @table.select {|point| point.abs_freq == @table.max_abs_freq}
    end

    def abs_freqs
      @table.rows.map do |row|
        row.map do |point|
          point.abs_freq
        end
      end
    end

    def rel_freqs
      abs_freqs.map do |row|
        row.map do |abs_freq|
          abs_freq / @table.sum_of_abs_freqs.to_f
        end
      end
    end

    def abs_freq_at(point)
      point_at(point).abs_freq
    end

    def point_at(*args)
      @table.point_at(args)
   end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
require 'spec_helper'

describe Battleship::Board do
  before do
    @miss_1 = Battleship::Point.new(1, 10, :missed)
    @miss_2 = Battleship::Point.new(2, 2, :missed)
    @miss_3 = Battleship::Point.new(3, 8, :missed)
    @miss_4 = Battleship::Point.new(4, 4, :missed)
    @miss_5 = Battleship::Point.new(5, 6, :missed)
    @miss_6 = Battleship::Point.new(6, 5, :missed)
    @miss_7 = Battleship::Point.new(7, 4, :missed)
    @miss_8 = Battleship::Point.new(7, 7, :missed)
    @miss_9 = Battleship::Point.new(9, 2, :missed)
    @miss_10 = Battleship::Point.new(9, 9, :missed)

    @misses = [@miss_1, @miss_2, @miss_3, @miss_4, @miss_5,
               @miss_6, @miss_7, @miss_8, @miss_9, @miss_10 ]

    @ship_1 = Battleship::VerticalShip.new(length: 5)
    @ship_2 = Battleship::HorizontalShip.new(length: 5)

    @ships = [@ship_1, @ship_2]

    @board = Battleship::Board.new(misses: @misses, ships: @ships)
  end

  describe '#row_length' do
    it 'should return 10' do
      expect(@board.row_length).to eq 10
    end
  end

  describe '#col_length' do
    it 'should return 10' do
      expect(@board.col_length).to eq 10
    end
  end

  describe '#miss?(point)' do
    it 'should return true if the point was a miss' do
      miss_point = Battleship::Point.new(1, 10 , :missed)
      expect( @board.miss?(miss_point)).to eq true
    end

    it 'should return false if the point was not a miss' do
      miss_point = Battleship::Point.new(1, 9 , :missed)
      expect( @board.miss?(miss_point)).to eq false
    end
  end

  describe '#point_at(row, col)' do
    it 'should return the point with those attributes' do
      row = 1
      col = 1

      point = @board.point_at(row, col)

      expect(point.row).to eq row
      expect(point.col).to eq col
    end
  end

  describe '#abs_freq_at(point)' do
    it'should return the number of possible hits' do
      point_of_interest = Battleship::Point.new(1, 1, :missed)
      expect(@board.abs_freq_at(point_of_interest)).to eq 2
    end
  end

  describe '#best_targets' do
    it 'returns the points with the highest likelihood of overlapping with a ship' do
      def has_point(some_point, occupied_points)
        occupied_points.any? {|point| point.row == some_point.row && point.col == some_point.col}
      end
      expect(has_point(Battleship::Point.new(1,5), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(2,7), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(3,3), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(4,9), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(5,1), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(5,3), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(6,10), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(8,3), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(8,6), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(8,8), @board.best_targets)).to eq true
      expect(has_point(Battleship::Point.new(10,6), @board.best_targets)).to eq true
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
module Battleship
  class Table
    include Enumerable

    attr_reader :row_length, :col_length

    def initialize(hash)
      @row_length = hash.fetch(:row_length)
      @col_length = hash.fetch(:col_length)
      @ships = hash.fetch(:ships)
      @misses = hash.fetch(:misses)
      recreate!
    end

    def max_abs_freq
      self.max {|point1, point2| point1.abs_freq <=> point2.abs_freq}.abs_freq
    end

    def rows
      @table
    end

    def recreate!
      @table = (1..row_length).inject([]) do |accum1, item1 |
        accum1 << (1..col_length).inject([]) do |accum2, item2|
        accum2 << Battleship::Point.new(item1, item2)
      end
      end

      @misses.each {|miss| point_at(miss).miss!}
    end

    def each(&block)
      (1..row_length).each do |row|
        (1..col_length).each do |col|
          block.call(point_at([row,col]))
        end
      end
    end

    def sum_of_abs_freqs
      self.inject(0) {|accum, point| accum = accum + point.abs_freq }
    end

    def recalculate_abs_freq!
      recreate!

      @ships.each do |ship|
        ship.table = self
        self.each do |point|
          ship.start_at(point)
          ship.abs_freq!
        end
      end
    end

    def point_at(*args)
      args.flatten!
      row, col = 0,0

      if args.length == 1
        point = args.first
        row, col = point.row, point.col
      else
        row = args[0]
        col = args[1]
      end

      @table[row-1][col-1]
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
require 'spec_helper'

describe Battleship::Table do
  describe '#rows' do
    it 'should return the rows' do
      ships = []
      misses = []
      hash = {row_length: 2, col_length: 1, ships: ships, misses: misses}
      table = Battleship::Table.new(hash)
      table.recreate!
      expect(table.rows[0][0].row).to eq 1
      expect(table.rows[0][0].col).to eq 1

      expect(table.rows[1][0].row).to eq 2
      expect(table.rows[1][0].col).to eq 1
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
module Battleship
  class VerticalShip < Battleship::Ship
    def occupies_point?(row, col)
      starting_point.col == col &&
        (starting_point.row...starting_point.row + @length).any? {|item| item == row}
    end

    def fully_onboard?
      @table.row_length >= @starting_point.row - 1 + @length
    end

    def occupied_points
      (@starting_point.row...@starting_point.row + @length).map do |row|
        @table.point_at(row, @starting_point.col)
      end
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
require 'spec_helper'

describe Battleship::VerticalShip do
  before do
    @starting_point = Battleship::Point.new(1,1)
    @table = (1..3).map do |row|
      (1..3).map do |col|
        Battleship::Point.new(row,col)
      end
    end

    def @table.row_length; 3; end
    def @table.col_length; 3; end
    def @table.point_at(row, col)
      self[row-1][col-1]
    end
    @table[2][2].miss!

    def has_point(some_point, occupied_points)
      occupied_points.any? {|point| point.row == some_point.row && point.col == some_point.col}
    end
  end

  describe '#occupied_points' do
    it 'returns a list of occupied points' do
      def @table.point_at(row, col)
        self[row-1][col-1]
      end
      vertical_ship = Battleship::VerticalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)

      occupied_points = vertical_ship.occupied_points

      expect(has_point(Battleship::Point.new(1,1), occupied_points)).to eq true
      expect(has_point(Battleship::Point.new(2,1), occupied_points)).to eq true
      expect(has_point(Battleship::Point.new(3,1), occupied_points)).to eq false
    end
  end

  describe '#occupies_a_missed_point?' do
    it 'returns true if ship occupies a missed point' do
      starting_point = Battleship::Point.new(2,3)
      vertical_ship = Battleship::VerticalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: starting_point)
      expect(vertical_ship).to be_occupies_a_missed_point
    end

    it 'returns false if ship does not occupy a missed point' do
      starting_point = Battleship::Point.new(1,1)
      vertical_ship = Battleship::VerticalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: starting_point)
      expect(vertical_ship).not_to be_occupies_a_missed_point
    end
  end

  describe '#occupies?(point)' do
    it 'returns true if occupies the point' do
      vertical_ship = Battleship::VerticalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)

      expect(vertical_ship.occupies_point?(1,1)).to eq true
      expect(vertical_ship.occupies_point?(2,1)).to eq true
      expect(vertical_ship.occupies_point?(3,1)).to eq false
    end
  end

  describe '#fully_onboard?' do
    it 'returns true if no part of the ship is off the board' do
      vertical_ship = Battleship::VerticalShip.new(length: 2,
                                                   orientation: :vertical,
                                                   table: @table,
                                                   starting_point: @starting_point)
      expect(vertical_ship).to be_fully_onboard

      vertical_ship.start_at(Battleship::Point.new(2,1))
      expect(vertical_ship).to be_fully_onboard

    end

    it 'returns false if part of the ship is off the board' do
      vertical_ship = Battleship::VerticalShip.new(length: 2,
                                                   orientation: :vertical,
                                                   table: @table,
                                                   starting_point: @starting_point)
      vertical_ship.start_at(Battleship::Point.new(3,1))
      expect(vertical_ship).not_to be_fully_onboard
    end
  end

  describe '#abs_freq!' do
    it 'should update the values of occupied points' do
      vertical_ship = Battleship::VerticalShip.new(length: 2,
                                                   orientation: :vertical,
                                                   table: @table,
                                                   starting_point: @starting_point)
      vertical_ship.abs_freq!
      expect(@table.point_at(1,1).abs_freq).to eq 1
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
module Battleship
  class HorizontalShip < Battleship::Ship
    def fully_onboard?
      @table.col_length >= @starting_point.col - 1 + @length
    end

    def occupies_point?(row, col)
      starting_point.row == row &&
        (starting_point.col...starting_point.col + @length).any? {|item| item == col}
    end

    def occupied_points
      (@starting_point.col...@starting_point.col + @length).map do |col|
        @table.point_at(@starting_point.row, col)
      end
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
require 'spec_helper'

describe Battleship::HorizontalShip do
  before do
    @starting_point = Battleship::Point.new(1,1)
    @table = (1..3).map do |row|
      (1..3).map do |col|
        Battleship::Point.new(row,col)
      end
    end

    def @table.row_length; 3; end
    def @table.col_length; 3; end
    def has_point(some_point, occupied_points)
      occupied_points.any? {|point| point.row == some_point.row && point.col == some_point.col}
    end
    @table[2][2].miss!

    def @table.point_at(row, col)
      self[row-1][col-1]
    end
  end

  describe '#occupies?(point)' do
    it 'returns true if occupies the point' do
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)

      expect(horizontal_ship.occupies_point?(1,1)).to eq true
      expect(horizontal_ship.occupies_point?(1,2)).to eq true
      expect(horizontal_ship.occupies_point?(1,3)).to eq false
    end
  end

  describe '#occupied_points' do
    it 'returns a list of occupied points' do
      def @table.point_at(row, col)
        self[row-1][col-1]
      end
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)

      occupied_points = horizontal_ship.occupied_points

      expect(has_point(Battleship::Point.new(1,1), occupied_points)).to eq true
      expect(has_point(Battleship::Point.new(1,2), occupied_points)).to eq true
      expect(has_point(Battleship::Point.new(1,3), occupied_points)).to eq false
    end
  end

  describe '#occupies_a_missed_point?' do
    it 'returns true if ship occupies a missed point' do
      starting_point = Battleship::Point.new(3,2)
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: starting_point)
      expect(horizontal_ship).to be_occupies_a_missed_point
    end

    it 'returns false if ship does not occupy a missed point' do
      starting_point = Battleship::Point.new(2,2)
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: starting_point)
      expect(horizontal_ship).not_to be_occupies_a_missed_point
    end
  end

  describe '#occupies_valid_points?' do
    it 'returns true if all points are valid' do
      starting_point = Battleship::Point.new(1,1)
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: starting_point)
      expect(horizontal_ship).to be_occupies_valid_points
    end

    it 'returns false if some points are not valid' do
      starting_point = Battleship::Point.new(3,3)
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: starting_point)
      expect(horizontal_ship).not_to be_occupies_valid_points
    end
  end

  describe '#fully_onboard?' do
    it 'returns true if no part of the ship is off the board' do
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)
      expect(horizontal_ship).to be_fully_onboard

      horizontal_ship.start_at(Battleship::Point.new(1,2))
      expect(horizontal_ship).to be_fully_onboard
    end

    it 'returns false if part of the ship is off the board' do
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)
      horizontal_ship.start_at(Battleship::Point.new(1,3))
      expect(horizontal_ship).not_to be_fully_onboard
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
module Battleship
  class Ship
    attr_reader :orientation, :starting_point
    attr_accessor :table

    def initialize(hash)
      @length = hash.fetch(:length)
      @table = hash.fetch(:table) { :no_table_initialized }
      @starting_point = hash.fetch(:starting_point) { :no_starting_point }
    end

    def start_at(point)
      @starting_point = point
    end

    def occupies_valid_points?
      fully_onboard? && !occupies_a_missed_point?
    end

    def occupies_a_missed_point?
      occupied_points.any? {|point| point.missed? }
    end

    def abs_freq!
      occupied_points.each {|point| point.abs_freq += 1} if self.occupies_valid_points?
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
require 'spec_helper'

describe Battleship::Ship do
  before do
    @starting_point = Battleship::Point.new(1,1)
    @table = (1..3).map do |row|
      (1..3).map do |col|
        Battleship::Point.new(row,col)
      end
    end

    def @table.row_length; 3; end
    def @table.col_length; 3; end
  end

  describe '#occupies?(point)' do
    it 'returns true if occupies the point' do
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)

      expect(horizontal_ship.occupies_point?(1,1)).to eq true
      expect(horizontal_ship.occupies_point?(1,2)).to eq true
      expect(horizontal_ship.occupies_point?(1,3)).to eq false
    end
  end

  describe '#occupied_points' do
    it 'returns a list of occupied points' do
      def @table.point_at(row, col)
        self[row-1][col-1]
      end
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)

      occupied_points = horizontal_ship.occupied_points
      def has_point(some_point, occupied_points)
        occupied_points.any? {|point| point.row == some_point.row && point.col == some_point.col}
      end

      expect(has_point(Battleship::Point.new(1,1), occupied_points)).to eq true
      expect(has_point(Battleship::Point.new(1,2), occupied_points)).to eq true
      expect(has_point(Battleship::Point.new(1,3), occupied_points)).to eq false
    end
  end

  describe '#fully_onboard?' do
    it 'returns true if no part of the ship is off the board' do
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)
      expect(horizontal_ship).to be_fully_onboard

      horizontal_ship.start_at(Battleship::Point.new(1,2))
      expect(horizontal_ship).to be_fully_onboard

    end

    it 'returns false if part of the ship is off the board' do
      horizontal_ship = Battleship::HorizontalShip.new(length: 2,
                                                       table: @table,
                                                       starting_point: @starting_point)
      horizontal_ship.start_at(Battleship::Point.new(1,3))
      expect(horizontal_ship).not_to be_fully_onboard
    end

  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
module Battleship
  class Point
    attr_reader :row, :col
    attr_accessor :abs_freq

    def initialize(row, col, *args)
      @row = row
      @col = col
      @abs_freq = 0
      @state = args.first || :untried
    end

    def hit!
      @state = :hit
    end

    def hit?
      @state == :hit
    end

    def miss!
      @state = :missed
    end

    def missed?
      @state == :missed
    end

    def untried?
      @state == :untried
    end

    def same_as?(point)
      row == point.row && col == point.col
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
require 'spec_helper'

describe Battleship::Point do
  describe '#row' do
    it 'should return the row' do
      bp = Battleship::Point.new(1,2)
      expect(bp.row).to eq 1
    end
  end

  describe '#col' do
    it 'should return the col' do
      bp = Battleship::Point.new(1,2)
      expect(bp.col).to eq 2
    end
  end

  describe '#miss!' do
    it 'sets the state of the point to :miss' do
      bp = Battleship::Point.new(1,2)
      bp.miss!

      expect(bp).to be_missed
    end
  end

  describe '#same_as?(point)' do
    it 'should be true if point has the same coordinates as the given point' do
      bp = Battleship::Point.new(1,2)
      expect(bp.same_as?(bp)).to eq true
    end
  end

  describe '#hit!' do
    it 'sets the state of the point to :hit' do
      bp = Battleship::Point.new(1,2)
      bp.hit!

      expect(bp).to be_hit
    end
  end

  it 'should be untried at first' do
    bp = Battleship::Point.new(1,2)
    expect(bp).to be_untried
  end

  it 'can be initialized to being missed' do
    bp = Battleship::Point.new(1,2, :missed)
    expect(bp).to be_missed
  end
end