class Digiproc::Strategies::BFConvolutionStrategy

Strategy for convolving two arrays of numbers This is an O(n^2) operation, it is more time efficient to use FFT to perform this calculation

Public Class Methods

conv(data1, data2) click to toggle source

Input Args

data1

Array

data2

Array

Output

convolution

Numeric

# File lib/strategies/convolution/bf_conv.rb, line 13
def self.conv(data1, data2)
    dynamic_data = data1.dup
    static_data = data2.dup
    conv_sum = []
    n = 0
    start, stop = conv_overlap_area(static_data.length, dynamic_data.length, n)
    while start <= stop
        sum = 0
        for val in start..stop
            sum += static_data[val] * dynamic_data[transform_to_local_index(val, n)]
        end
        conv_sum << sum
        n = conv_sum.length
        start, stop = conv_overlap_area(static_data.length, dynamic_data.length, n)
    end
    conv_sum
  end

Private Class Methods

conv_overlap_area(static_len, dynamic_len, n) click to toggle source

Gives start and stop values of overlap inclusive

# File lib/strategies/convolution/bf_conv.rb, line 35
def self.conv_overlap_area(static_len, dynamic_len, n)
    dynamic_lo = transform_to_global_index(dynamic_len - 1, n)
    dynamic_hi = transform_to_global_index(0, n)
    static_lo = 0
    static_hi = static_len - 1
    start = dynamic_lo > static_lo ? dynamic_lo : static_lo
    stop = dynamic_hi < static_hi ? dynamic_hi : static_hi
    return [start, stop]
end
transform_index(index, xform) click to toggle source
# File lib/strategies/convolution/bf_conv.rb, line 45
def self.transform_index(index, xform)
    xform.call(index)
end
transform_to_global_index(index, n) click to toggle source
# File lib/strategies/convolution/bf_conv.rb, line 49
def self.transform_to_global_index(index, n)
    transform_index(index, ->(i){ n - i })
end
transform_to_local_index(index, n) click to toggle source
# File lib/strategies/convolution/bf_conv.rb, line 53
def self.transform_to_local_index(index, n)
    transform_index(index, ->(i){ n - i})
end