digiproc 0.1.0

data/lib/fft.rb

@@ -0,0 +1,255 @@
+##
+# Class to calculate and store the Discrete Fourier Transform of a siugnal
+class Digiproc::FFT
+
+    ##
+    # Calculate the FFT of given time data
+    # == Input arg
+    # time_data:: Array[Numeric]
+    def self.calculate(time_data)
+        Radix2Strategy.calculate(time_data)
+    end
+
+    ##
+    # Calculate the IFFT of the given frequency data
+    # Input frequency data, perform the Inverse FFT to populate the time data
+    # == Input arg
+    # data:: Array[Numeric]
+    def self.new_from_spectrum(data)
+        time_data = Digiproc::Strategies::IFFTConjugateStrategy.new(data)
+        new(freq_data: data, time_data: time_data)
+    end
+
+    # Reader for @data
+    # Allows for lazy calculation of @data (which holds frequency domain data)
+    # If @data is nil, the #calculate method will be called
+    def data
+        calculate if @data.nil?
+        @data
+    end
+
+    attr_accessor :strategy, :window, :processed_time_data, :time_data_size, :inverse_strategy
+    include Digiproc::Convolvable::InstanceMethods, Digiproc::Plottable::InstanceMethods
+
+
+    ##
+    # == Input Args
+    # strategy:: FFT Strategy, see Digiproc::Strategies::Radix2Strategy to see required Protocol
+    # time_data:: Array[Numeric] time data to be transformed to the frequency domain via the FFT strategy
+    # size (Optional):: Integer, defaults to nil. If not set, your data will be zero padded to the closest higher power of 2 (for Radix2Strategy), or not changed at all
+    # window (Optional):: Digiproc::Window, defaults to Digiproc::RectangularWindow. Changes the window used during #process_with_window method
+    # freq_data (Optional):: Array[Niumeric], required if time_data not given
+    # inverse_strategy (Optional):: Digiproc::Strategies::IFFTConjugateStrategy is the default value and shows the required protocol
+    # Note: Using size with a Radix2Strategy will only ensure a minimum amount of 
+    # zero-padding, it will mostly likely not determine the final size of the time_data
+    # You need to have EITHER time_data or freq_data, but not both.
+    def initialize(strategy: Digiproc::Strategies::Radix2Strategy, time_data: nil, size: nil, window: Digiproc::RectangularWindow, freq_data: nil, inverse_strategy: Digiproc::Strategies::IFFTConjugateStrategy)
+        raise ArgumentError.new("Either time or frequency data must be given") if time_data.nil? and freq_data.nil?
+        raise ArgumentError.new('Size must be an integer') if not size.nil? and not size.is_a?(Integer) 
+        raise ArguemntError.new('Size must be greater than zero') if not size.nil? and size <= 0 
+        raise ArgumentError.new('time_data must be an array') if not time_data.respond_to?(:calculate) and not time_data.is_a? Array
+        
+        if time_data.is_a? Array
+            @time_data_size = time_data.length
+            if not size.nil?
+                if size <= time_data.length
+                    @time_data = time_data.dup.map{ |val| val.dup }.take(size)
+                else 
+                    zero_fill = Array.new(size - time_data.length, 0)
+                    @time_data = time_data.dup.map{ |val| val.dup }.concat zero_fill
+                end
+            else
+                @time_data = time_data.dup.map{ |val| val.dup}
+            end
+            @strategy = strategy.new(@time_data.map{ |val| val.dup})
+            @window = window.new(size: time_data_size)
+        else
+            @time_data = time_data
+            @strategy = strategy.new
+            @window = window.new(size: freq_data.length)
+        end
+        @inverse_strategy = inverse_strategy
+        @data = freq_data
+    end
+
+    ##
+    # Performs FFT caclulation if not yet performed. Returns FFT data as an Array of Floats (or an array of Complex numbers)
+    def calculate
+        self.strategy.data = time_data if @strategy.data.nil?
+        @fft = self.strategy.calculate
+        @data = @fft
+    end
+
+    ##
+    # Input argument of an Integer describing the required size of the FFT. IF using a strategy requiring a certain amount of 
+    # data points (ie Radix2), you will be guaranteed tha the FFT is greater than or equal to the input size. Otherwise, your FFT will be this size
+    def calculate_at_size(size)
+        if size > self.data.size
+            zero_fill = Array.new(size - @time_data.length, 0)
+            @time_data = time_data.concat zero_fill
+        elsif size < self.data.size
+            @time_data = time_data.take(size)
+        end
+        self.strategy.data = time_data
+        calculate
+    end
+
+    ##
+    # Calculate the IFFT of the frequency data
+    def ifft
+        inverse_strategy.new(data).calculate
+    end
+
+    ##
+    # Calculate the IFFT and return it as a Digiproc::DigitalSignal
+    def ifft_ds
+        Digiproc::DigitalSignal.new(data: ifft)
+    end
+
+
+    ##
+    # Returns the time_data as an Array of Numerics (floats or Complex numbers)
+    def time_data
+        if @time_data.is_a? Array
+            @time_data
+        elsif @time_data.respond_to? :calculate
+            @time_data = @time_data.calculate
+        else
+            raise TypeError.new("time_data needs to be an array or an ifft strategy, not a #{@time_data.class}")
+        end
+    end
+
+    ##
+    # Processes the time_data with the chosen window valuesand calculates the FFT based of of the window-processed time domain signals
+    def process_with_window
+        @processed_time_data = time_data.take(time_data_size).times self.window.values
+        self.strategy.data = @processed_time_data
+        @fft = self.strategy.calculate
+        @data = @fft
+    end
+
+    ##
+    # Returns the frequency domain data as an Array of Numerics (Float or Complex)
+    def fft
+        self.data
+    end
+
+    ##
+    # Return the number of frequency domain datapoints
+    def size
+        self.data.length
+    end
+
+    ##
+    # Return the magnitude of the frequency domain values as an array of floats
+    def magnitude
+        data.map do |f|
+            f.abs
+        end
+    end
+
+    ##
+    # Return the complex conjugate of the frequency domain data, as an array of numerics (float or complex)
+    def conjugate
+        self.data.map(&:conjugate)
+    end
+
+    ##
+    # Return the decible of the frequency domain data, as an Array of floats
+    def dB
+        self.magnitude.map do |m|
+            Math.db(m)
+        end
+    end
+
+    ##
+    # Returns the angle of the frequency domain data, as an array of floats (in radians)
+    def angle
+        self.data.map(&:angle)
+    end
+
+    ##
+    # Returns the real part of the frequency domain data, as an array of floats
+    def real
+        self.data.map(&:real)
+    end
+
+    ##
+    # Returns the imaginary part of the frequency domain data, as an array of floats
+    def imaginary
+        self.data.map(&:imaginary)
+    end
+
+    ##
+    # Returns the maximum value(s) of the magnitude of the frequency signal as an Array of  OpenStructs with 
+    # an index and value property. 
+    # == Input arg
+    # num (Optional):: The number of maxima desired, defaults to 1
+    def maxima(num = 1)
+        Digiproc::DataProperties.maxima(self.magnitude, num)
+    end
+
+    ##
+    # Returns the local maximum value(s) of the  magnitude of the frequency signal as an Array of  OpenStructs with 
+    # an index and value property. 
+    # Local maxima are determined by Digiproc::DataProperties.local_maxima, and the returned maxima are determined based off of 
+    # their relative hight to adjacent maxima. This is useful for looking for spikes in frequency data
+    # == Input arg
+    # num (Optional):: The number of maxima desired, defaults to 1
+    def local_maxima(num = 1)
+        Digiproc::DataProperties.local_maxima(self.magnitude, num)
+    end
+
+    ##
+    # Allows multioplication of FFT objects with anything with a @data reader which holds an Array of Numerics.
+    # The return value is a new FFT object whose frequency data is the element-by-element multiplication of the two data arrays
+    def *(obj)
+        if obj.respond_to?(:data) 
+            return self.class.new_from_spectrum(self.data.times obj.data)
+        elsif obj.is_a? Array 
+            return self.class.new_from_spectrum(self.data.times obj)
+        end
+    end
+
+    ##
+    # Uses Plottable module to plot the db values
+    def plot_db(path: "./") 
+        self.plot(method: :dB, xsteps: 8, path: path) do |g|
+            g.title = "Decibles"
+            g.x_axis_label = "Normalized Frequency"
+            g.y_axis_label = "Magnitude"
+        end
+    end
+
+    ## 
+    # uses Plottable module to plot the magnitude values
+    def plot_magnitude(path: "./" )
+        self.plot(method: :magnitude, xsteps: 8, path: path) do |g|
+            g.title = "Magnitude"
+            g.x_axis_label = "Normalized Frequency"
+            g.y_axis_label = "Magnitude"
+        end
+    end
+
+
+    ##
+    # TODO: Remove
+    # plots magnitude using Gruff directly
+    def graph_magnitude(file_name = "fft")
+        if @fft
+            g = Gruff::Line.new
+            g.data :fft, self.magnitude
+            g.write("./#{file_name}.png")
+        end
+    end
+
+    ##
+    # TODO: Remove
+    # Plots time data using Gruff directly
+    def graph_time_data
+        g = Gruff::Line.new
+        g.data :data, @time_data
+    end
+
+
+end

data/lib/filters/bandpass_filter.rb

@@ -0,0 +1,43 @@
+##
+# Creates a Bandpass Filter via the Windowing method. 
+class Digiproc::BandpassFilter < Digiproc::DigitalFilter
+    attr_accessor :equation
+
+    ##
+    # == Inputs
+    # size:: [Integer] number of datapoints window should be 
+    # window:: [Digiproc::WindowStrategy] desired window strategy
+    # wo:: [Float] center frequency in radians
+    # bw:: [Float] bandwidth in radians
+    # wcl:: [Float] lower cutoff frequency in radians
+    # wch:: [Float] higher cutoff frequency in radians
+    # correct:: [Boolean] perform frequency corrections to make frequency points more accurate. Defaults to true
+    #
+    # Must have either `wo` and `bw` or `wcl` and `wch`
+    #
+    ## Digiproc::BandpassFilter.new(size: 1000, wo: Math::PI / 4, bw: Math::PI / 10) 
+
+    def initialize(size:, window: Digiproc::RectangularWindow, wo: nil, bw: nil, wcl: nil , wch: nil, correct: true )
+
+        super(size: size, window: window)
+
+        if !!wo && !!bw
+            bw += @window.transition_width * 2 * PI if correct
+            wcl = wo - bw / 2.0
+            wch = wo + bw / 2.0
+        else
+            raise ArgumentError.new("You must provide either bandwidth and center freq or frequency bands") if wcl.nil? or wch.nil? 
+            wcl -= @window.transition_width * PI if correct
+            wch += @window.transition_width * PI if correct
+            bw = wch - wcl
+            wo = (wch + wcl) / 2.0
+        end
+        @equation = ->(n){ 
+            n == 0 ?  bw / PI : ((Math.sin(bw * n / 2.0)) / (PI * n)) * (2.0 * Math.cos(n * wo))
+        }
+        ideal_filter = calculate_ideal
+        @weights = self.window.values.times ideal_filter
+        @fft = Digiproc::FFT.new(time_data: self.weights)
+        @fft.calculate
+    end
+end

data/lib/filters/bandstop_filter.rb

@@ -0,0 +1,44 @@
+
+## 
+# Creates a bandstop filter via the Windowing Method
+
+class Digiproc::BandstopFilter < Digiproc::DigitalFilter
+    attr_accessor :equation
+
+    ##
+    # == Inputs
+    # size:: [Integer] number of datapoints window should be 
+    # window:: [Digiproc::WindowStrategy] desired window strategy
+    # wo:: [Float] center frequency in radians
+    # bw:: [Float] bandwidth in radians
+    # wlp_upper:: [Float] Upper frequency limit (radians) of the lowpass passband
+    # whp_lower:: [Float] Lower frequency limit (radians) of the highpass passband
+    # correct:: [Boolean] perform frequency corrections to make frequency points more accurate. Defaults to true
+    #
+    # Must have either `wo` and `bw` or `wlp_upper` and `whp_lower`
+    # For wo and bw, include the "don't care" areas in the bandstop area
+    #
+    ## Digiproc::BandpassFilter.new(size: 1000, wo: Math::PI / 4, bw: Math::PI / 10) 
+    def initialize(size:, window: RectangularWindow, wo: nil, bw: nil, wlp_upper: nil , whp_lower: nil, correct: true )
+
+        super(size: size, window: window)
+        
+        if !!wo && !!bw
+            bw += (@window.transition_width * 2 * PI)
+            wlp_upper = wo - bw / 2.0
+            whp_lower = wo + bw / 2.0
+        else
+            raise ArgumentError.new("You must provide either bandwidth and center freq or frequency bands") if wlp_upper.nil? or whp_lower.nil? 
+            wlp_upper += @window.transition_width * PI if correct
+            whp_lower -= @window.transition_width * PI if correct
+        end
+        
+        @equation = ->(n){ 
+            n == 0 ?  (wlp_upper / PI) + (( PI - whp_lower )/ PI ) : ((Math.sin(wlp_upper * n) - Math.sin(whp_lower * n)) / (PI * n))
+        }
+        ideal_filter = calculate_ideal
+        @weights = self.window.values.times ideal_filter
+        @fft = FFT.new(data: self.weights)
+        @fft.calculate
+    end
+end

data/lib/filters/digital_filter.rb

@@ -0,0 +1,59 @@
+##
+# Parent class to BandpassFilter, HighpassFilter, LowpassFilter, and BandstopFilter
+class Digiproc::DigitalFilter
+    PI = Math::PI
+
+    attr_accessor :size, :window, :fft, :weights
+
+    ##
+    # == Inputs
+    # size:: [Integer] number of window datapoints
+    # window:: [Digiproc::WindowStrategy] 
+    def initialize(size: , window: )
+        #TODO: allow size to be even
+        @size = size.even? ? size + 1 : size
+        @window = window.new(size: size)
+    end 
+
+    ##
+    # Ensures size is odd, and uses @equation to make a return Array of ideal filter values. 
+    # Used by the child class to multiply by the window to the return value of this method for final weights
+    def calculate_ideal
+        #TODO: allow size to be even
+        @size += 1 if @size.even?
+        n_vals = ((-1 * (@size - 1) / 2)..((@size - 1) / 2)).to_a
+        n_vals.map do |n|
+            @equation.call(n)
+        end
+    end
+
+
+    ##
+    # Zero pad @weights  to achieve a size of the input value. 
+    # set @fft to a new Digiproc::FFT, and calculate with the new padded data.
+    ## .set_fft_size(size [Integer])
+    def set_fft_size(size)
+        if size > @weights.length
+            zeros = Array.new(size - @weights.length, 0)
+            padded = @weights.concat(zeros)
+            @fft = Digiproc::FFT.new(data: padded)
+            @fft.calculate
+        end
+    end
+
+    ##
+    # return a Digiproc::DigitalSignal whose values are the weights of the filter
+    def to_ds
+        Digiproc::DigitalSignal.new(data: self.weights)
+    end
+
+    #TODO: Inorder to implement, must separately recalculate for weight at n = 0
+    # def shift_in_freq(normalized_freq)
+    #     eqn = ->(n){ Math::E ** Complex(0, -1 * normalized_freq * n)}
+    #     @weights = @weights.map.with_index do |w, i|
+    #         w * eqn.call(i)
+    #     end
+    # end
+
+
+end

data/lib/filters/highpass_filter.rb

@@ -0,0 +1,27 @@
+##
+# Creates a highpass filter via the windowing method
+class Digiproc::HighpassFilter < Digiproc::DigitalFilter
+    attr_accessor :equation
+
+    ##
+    # == Inputs
+    # size:: [Integer] number of datapoints window should be 
+    # window:: [Digiproc::WindowStrategy] desired window strategy
+    # wo:: [Float] center frequency in radians
+    # bw:: [Float] bandwidth in radians
+    # correct:: [Boolean] perform frequency corrections to make frequency points more accurate. Defaults to true
+    #
+    ## Digiproc::BandpassFilter.new(size: 1000, wo: Math::PI / 4, bw: Math::PI / 10) 
+    def initialize(size:, window: RectangularWindow, wc: , correct: true)
+        super(size: size, window: window)
+        wc = wc - @window.transition_width * PI if correct
+        @equation = ->(n){ 
+            n == 0 ?  (( PI - wc) / PI) :  (-1 * (Math.sin( wc * n) / (PI * n)))
+        }
+        ideal_filter = calculate_ideal
+        @weights = self.window.values.times ideal_filter
+        @fft = FFT.new(data: self.weights)
+        @fft.calculate
+    end
+
+end

data/lib/filters/lowpass_filter.rb

@@ -0,0 +1,27 @@
+##
+# Creates a Lowpass filter via the windowing method
+class Digiproc::LowpassFilter < Digiproc::DigitalFilter
+
+    attr_accessor :equation
+    
+    ##
+    # == Inputs
+    # size:: [Integer] number of datapoints window should be 
+    # window:: [Digiproc::WindowStrategy] desired window strategy
+    # wo:: [Float] center frequency in radians
+    # bw:: [Float] bandwidth in radians
+    # correct:: [Boolean] perform frequency corrections to make frequency points more accurate. Defaults to true
+    #
+    ## Digiproc::BandpassFilter.new(size: 1000, wo: Math::PI / 4, bw: Math::PI / 10) 
+    def initialize(size:, window: RectangularWindow, wc: , correct: true)
+        super(size: size, window: window)
+        wc = wc + @window.transition_width * PI if correct
+        @equation = ->(n){ 
+            n == 0 ? (wc / PI) : (Math.sin(wc * n) / (PI * n)) 
+        }
+        ideal_filter = calculate_ideal
+        @weights = self.window.values.times ideal_filter
+        @fft = Digiproc::FFT.new(time_data: self.weights)
+        @fft.calculate
+    end
+end

data/lib/functions.rb

@@ -0,0 +1,221 @@
+##
+# Contains many class methods which perform useful functions 
+module Digiproc::Functions
+
+    extend Digiproc::Convolvable::ClassMethods, Digiproc::FourierTransformable::GenericMethods, Digiproc::DataProperties
+
+    ##
+    # Performs cross correlation cacluatlino for two arrays of numerics
+    def self.cross_correlation(data1, data2)
+        self.conv(data1, data2.reverse)
+    end
+
+    ##
+    # Maps an array of numerics to a range defined by a min and max
+    # Output an array of samples mapped to within the bounds of the min and max
+    # == Input args
+    # samples:: Array of Numerics
+    # min:: Float, the minimum desired value of the new mapped data
+    # max:: Float, the maximum desired value of the new mapped data
+    def self.map_data_to_range(samples, min, max)
+        target_center = (max + min) / 2.0
+        target_range = max.to_f - min
+        smax, smin = samples.max, samples.min
+        sample_center = (smax + smin) / 2.0
+        sample_range = smax.to_f - smin
+        center_map = target_center - sample_center 
+        range_map = target_range / sample_range
+        mapping = ->(n){ (n + center_map) * range_map }
+        process(samples, mapping)
+    end
+
+    ##
+    # Return a lambda equation which will map a dataset within a starting min and max to a 
+    # new dataset with a different min and max.
+    # == Input Args
+    # starting_min:: Float, minimum val of data to be mapped
+    # starting_max:: Float, maximum val of data to be mapped
+    # target_min:: Float, minimum value of data after mapping
+    # target_max:: Float, maximum value of data after mapping
+    def self.map_to_eqn(starting_min, starting_max, target_min, target_max)
+        target_center = center_of(target_max, target_min)
+        target_range = range_of(target_max, target_min)
+        starting_center = center_of(starting_max, starting_min) 
+        starting_range = range_of(starting_max.to_f, starting_min)
+        range_map = target_range.to_f / starting_range
+        ->(n){ (n - starting_center) * range_map + target_center}
+    end
+
+    ##
+    # == Input args
+    # *args:: Can be a variable number of Floats, an array, or a hash with key value pairs of point locations with the value of probability values
+    # If a variable number of floats are an array of floats are given, they will be treated as points on a 1-dimentional line and the return will
+    # be an array of numbers which are the sampe points centered around the origin .
+    # If a hash is given, the keys will be assumed to be places on the 1D line and the values will be the corresponding probabilities of those points.
+    # The same calculation will be carried out, except taking inot account the appropriate weighting.
+    # Note: Arguents are X-dimensional ponins as array => optional hash value for probability
+    def self.translate_center_to_origin(*args)
+        args = args[0] if args.length == 1 and args.first.is_a? Enumerable
+        points = []
+        probabilities = []
+        dimensions = 0
+        if args.is_a? Hash 
+            args.each do |k,v|
+                points << k
+                probabilities << v
+            end
+        else
+            points = args
+            probabilities = points.map{ 1.0 / points.length }
+        end
+    
+        if probabilities.include?(nil)
+            probabilities.map{ 1.0 / points.length }
+        end
+        dimensions = points.first.length
+        weighted_points = points.map.with_index do |point, index|
+            point.map{|dimension| -1 * dimension * probabilities[index]}
+        end
+        a = weighted_points.reduce(Array.new(dimensions,0), :plus)
+        points.map{ |vector| vector.plus(a) }
+    end
+
+    ##
+    # Return the center of a max and min point
+    # == Input args
+    # max:: float
+    # min:: float
+    def self.center_of(max, min)
+        (max + min) / 2.0
+    end
+
+    ##
+    # Return the range of a max and min point
+    # == Input args
+    # max:: float
+    # min:: float
+    def self.range_of(max, min)
+        max.to_f - min
+    end
+
+    ##
+    # Return an arary of zeros of length num
+    # == Input args
+    # num:: Integer
+    def self.zeros(num)
+        Array.new(num, 0)
+    end
+    
+    ##
+    # Return an array of ones of length numn
+    # == Input args
+    # num:: Integer
+    def self.ones(num)
+        Array.new(num, 1)
+    end
+    
+    ##
+    # Similar to linspace in numpy, return an array of numbers given a min, max, and total number 
+    # of elements
+    # == Input args
+    # start:: flaot, the minimum number and index 0 of the output array
+    # stop:: float, the maximum number and last index of the output array
+    # number:: integer, the number of elements in the output array
+    def self.linspace(start, stop, number)
+        rng = 0...number
+        interval = (stop - start).to_f / (number - 1)
+        rng.map{ |val| start + interval * val }
+    end
+
+    ##
+    # Given an array of numerics, if it is monitonic (ie flat, increaseing, or decreasing), return
+    # a symbol representing its state. Return nil of the data is not monotonic
+    # == Input args
+    # data:: Array[Numeric]
+    def self.monotonic_state(data)
+        last_value = data.first
+        state = [:flat, :increasing, :decreasing]
+        state_index = 0
+        for i in 1...data.length do
+            return state[state_index] if state[state_index].nil? 
+            slope = data[i] - last_value
+            if slope > 0
+                state_index = 1 if state[:state_index] == :flat
+                return nil if state[:state_index] != :increasing
+            elsif slope < 0
+                state_index = 2 if state[:state_index] == :flat
+                return nil if state[:state_index] != :decreasing
+            end
+            last_value = data[i]
+        end
+        return state[:state_index]
+    end
+
+    ##
+    # Return true or false based on if the data is monotoic (ie has a consistant slope direction)
+    # ==Input Arg
+    # data:: Array[Numeric]
+    def self.monotonic?(data)
+        !!monotonic_state(data)
+    end
+
+    ##
+    # Transform a binary number represented in string form into an integer
+    # == Input Arg
+    # bin_str:: String
+    ## Digiproc::Functions.bin_str_to_i("101101") # => 45
+    def self.bin_str_to_i(bin_str)
+        str_arr = bin_str.split("").reverse
+        sum = 0
+        str_arr.each_with_index do |digit, index|
+            sum += digit.to_i * 2 ** index
+        end
+        sum
+    end
+
+    ##
+    # XOR two strings representing binary numbers, return the XOR of them in decimal
+    ## Digiproc::Functions.str_xor("1011","1001") # => 2
+    def self.str_xor(str1, str2)
+        bin_str_to_i(str1) ^ bin_str_to_i(str2)
+    end
+
+    
+
+    @fact_memo = {}
+
+    ##
+    # Given a number, return its factorial
+    def self.fact(n)
+        raise ArgumentError.new("n must be positive") if n < 0
+        return 1 if n <= 1
+        return @fact_memo[n] if not @fact_memo[n].nil?
+        x = n * fact(n - 1)
+        @fact_memo[n] = x
+        return x
+    end
+
+    # def self.populate_large_factorial_memoization
+    #     for i in 1..10 do 
+    #         fact(10000 * i)
+    #     end 
+    # end
+
+    ##
+    # Return the value of sinc(x), given an input x (float)
+    # sinc = sin(x) / x
+    def self.sinc(x)
+        return 1 if x == 0
+        Math.sin(x) / x.to_f
+    end 
+    
+    ##
+    # Maps values using the lambda equation
+    # == Input args
+    # values:: Collection of values
+    # eqn:: lambda 
+    def self.process(values, eqn)
+        values.map{ |val| eqn.call(val) }
+    end
+
+end