>_<.

require "matrix"

class BAM
    attr_reader :output_pattern
    
    def initialize(x_size, y_size)
        @x_size = x_size
        @y_size = y_size
        
        @w = Matrix[ *[].fill([].fill(0, 0, @y_size), 0, @x_size) ]
    end
    
    def learn(x_pattern, y_pattern)
        delta_w = Matrix[x_pattern].t * Matrix[y_pattern]        
        @w += delta_w
    end
    
    def recall(input, side)
        y_out = nil
        x_out = nil
        x_out_old = [].fill(0, 0..@x_size)
        y_out_old = [].fill(0, 0..@y_size)
        input_pattern = input.clone
        
        while true
            2.times do
                if side == :x
                    y_out = []
                    net_y = Matrix[input_pattern] * @w
                    net_y = *net_y.to_a.flatten
                    @y_size.times do |i|
                        y_out[i] = af(net_y[i], y_out_old[i])
                    end
                    
                    side = :y
                    input_pattern = y_out
                else
                    x_out = []
                    net_x = Matrix[input_pattern] * @w.t
                    net_x = *net_x.to_a.flatten
                    @x_size.times do |i|
                        x_out[i] = af(net_x[i], x_out_old[i])
                    end
                    
                    side = :x
                    input_pattern = x_out
                end
            end
            
            if x_out == x_out_old and y_out == y_out_old
                if side == :x
                    @output_pattern = y_out
                else
                    @output_pattern = x_out
                end
                
                break
            else
                x_out_old = x_out
                y_out_old = y_out
            end
        end
    end
    
    private
    def af(x, net)
        if x > 0
            +1
        elsif x == 0
            net
        else
            -1
        end
    end
end