digiproc 0.1.0

data/examples/functions/minimize_energy.rb

@@ -0,0 +1,29 @@
+points1 = [[2,1,3],[1,2,4],[-3,-2,-4],[1,-2,4]]
+points2 = [[0,1,0],[1,3,3],[-2,-5,-4],[-1,-2,-4]]
+
+# => #translate_center_to_origin can take arguments of individual arrays (of the same length), an array of the points, or an array of a hash with
+# the points as the keys and the probability of the points as the value. If no probabilities are given, each point is assumed to be
+# equiprobable. The points are then centered around the origin as to reduce the total energy of the points.
+
+min_energy_1 = Digiproc::Functions.translate_center_to_origin(points1)
+min_energy_2 = Digiproc::Functions.translate_center_to_origin(points2)
+
+puts "Translated version of #{points1}: \n\t\n#{min_energy_1}"
+puts "\n\n"
+puts "Translated version of #{points2}: \n\t\n#{min_energy_2}"
+puts "\n\n"
+probabilities = [1.0/3, 1.0 / 6, 1.0/6, 1.0/3]
+points_probs_1 = {}
+points_probs_2 = {}
+
+for i in 0...points1.length do 
+    points_probs_1[points1[i]] = probabilities[i]
+    points_probs_2[points2[i]] = probabilities[i]
+end
+
+min_energy_3 = Digiproc::Functions.translate_center_to_origin(points_probs_1)
+min_energy_4 = Digiproc::Functions.translate_center_to_origin(points_probs_2)
+
+puts "Translated version of #{points_probs_1}: \n\t\n#{min_energy_3}"
+puts "\n\n"
+puts "Translated version of #{points_probs_2}: \n\t\n#{min_energy_4}"

data/examples/functions/orthoganalize.rb

@@ -0,0 +1,18 @@
+
+gs = Digiproc::Strategies::GramSchmidtOrthonormalize
+eqn1 = ->(t){Math::E ** (-t)}
+eqn2 = ->(t){Math::E ** (-2*t)}
+eqn3 = ->(t){Math::E ** (-3*t)}
+
+set1 = Digiproc::AnalogSignal.new(eqn: eqn1, size: 10000, sample_rate:0.1).digitize
+set2 = Digiproc::AnalogSignal.new(eqn: eqn2, size: 10000, sample_rate:0.1).digitize
+set3 = Digiproc::AnalogSignal.new(eqn: eqn3, size: 10000, sample_rate:0.1).digitize
+
+out1, out2, out3 = gs.new([set1,set2,set3]).output
+
+puts "out1 dot out2 = #{out1.dot out2}"
+puts "out1 dot out3 = #{out1.dot out3}"
+puts "out2 dot out3 = #{out2.dot out3}"
+
+puts "All three are orthogonal becacuse their dot products are 0"
+

data/examples/functions/simple_functions.rb

@@ -0,0 +1,81 @@
+# ***** Simple functions examples from Digiproc::Functions and Digiproc::Probability *****
+
+
+#Gaussian random number generator
+pfuncs = Digiproc::Probability
+nums = []
+10.times do 
+    nums << pfuncs.nrand
+end
+
+puts "Numbers from gaussian distribution:"
+puts nums.to_s
+puts
+
+# Pearson's Correlation Coefficient from Digiproc::Probability
+dist1 = Digiproc::Probability::RealizedGaussianDistribution.new(mean: 0, stddev: 10, size: 100).data
+dist2 = Digiproc::Probability::RealizedGaussianDistribution.new(mean: 0, stddev: 10, size: 100).data
+corr_coeff = pfuncs.correlation_coefficient(dist1, dist2)
+corr_coeff_2 = pfuncs.correlation_coefficient(dist1, Digiproc::Functions.process(dist1, ->(x){x * -2 + 3} ))
+
+puts "Correlation coefficient, different random distributions: #{corr_coeff}"
+puts "Correlation coefficient, gain and shifted from same distribution #{corr_coeff_2}"
+puts
+
+# stddev, mean, variance, covariance, cdf, q, pdf
+
+distribution = Digiproc::Probability::RealizedGaussianDistribution.new(mean: 0, stddev: 10, size: 100).data
+
+mean = pfuncs.mean(distribution)
+stddev = pfuncs.stddev(distribution)
+variance = pfuncs.variance(distribution)
+cov = pfuncs.covariance(distribution, distribution)
+pdf = pfuncs.pdf(distribution)
+cdf = pfuncs.normal_cdf(5, mean, stddev)
+q = pfuncs.normal_q(5, mean, stddev)
+
+
+puts "Mean: #{mean}"
+puts "Std. Deviation: #{stddev}"
+puts "Variance: #{variance}"
+puts "Covaraince: #{cov}"
+# puts "PDF: #{pdf}" => Long print - a big hash of value => occurances count 
+puts "CDF of 5, at mean: #{mean}, stddev: #{stddev}: #{cdf}"
+puts "Q of 5, at mean: #{mean}, stddev: #{stddev}: #{q}"
+puts 
+puts
+
+# linspace(start, stop, num_points)
+
+t = Digiproc::Functions.linspace(0, 5, 10)
+puts "Linspace from 0 to 5, 10 numbers"
+puts t.to_s
+puts
+
+# factorial (includes memoization, you can build memory to allow fact of larger numbers by incrementing fact size) 
+
+fns = Digiproc::Functions
+puts "Factorial of 23: #{fns.fact(23)}"
+puts
+
+# process(vals, eqn) processes values with an equation
+
+eqn = ->(x){ x ** 2 }
+vals = [1,2,3,4,5,6]
+out = fns.process(vals, eqn)
+puts "Output of process: #{out}"
+puts 
+puts
+
+# maxima, local maxima (relative maxima in order (forward and reverse) -> useful when trying to find local maxima in a fft plot
+# where signals of interest are local maxima not absolute maxima)
+
+vals = [1,2,3,4,5,6,5,4,5,4,3,2,5,2,3,4,3,2,3,4,9,6,7,8,7,1]
+
+maxima = fns.maxima(vals)
+top_three_maxima = fns.maxima(vals, 3)
+local_maximas = fns.local_maxima(vals, 3)
+
+puts "Maxima: #{maxima}"
+puts "Top 3 maxima: #{top_three_maxima}"
+puts "Local maxima (3): #{local_maximas}"

data/examples/linear_algebra/diverging_sys.rb

@@ -0,0 +1,13 @@
+# Attempt to solve a system of linear equations using these strategies
+
+a = [[2,-3,0],[1,3,-10],[3,0,1]]
+b = [-7,9,13]
+
+js = Digiproc::Strategies::JacobiStrategy.new(a,b)
+gs = Digiproc::Strategies::GaussSeidelStrategy.new(a,b)
+sor = Digiproc::Strategies::Sor2Strategy.new(a,b)
+
+puts js.calculate
+puts gs.calculate
+puts sor.calculate(w: 0.1)
+puts (Matrix.rows(a).inv * Matrix.column_vector(b)).map(&:to_f)

data/examples/linear_algebra/iterative_sys_of_eqns_methods.rb

@@ -0,0 +1,27 @@
+# Iteratively solve a system of linear equations using these strategies
+
+a = [[10,4,0,0],[0,7,0,3],[9,0,8,1],[1,0,0,1]]
+b = [52,24,61,5]
+
+js = Digiproc::Strategies::JacobiStrategy.new(a,b)
+gs = Digiproc::Strategies::GaussSeidelStrategy.new(a,b)
+sor = Digiproc::Strategies::SorStrategy.new(a,b)
+
+puts js.calculate
+puts gs.calculate
+puts sor.calculate(w: 0.5)
+puts (Matrix.rows(a).inv * Matrix.column_vector(b)).map(&:to_f)
+
+a = [
+        [1,-1,-1,-1,-1,-1],
+        [-1,2,0,0,0,0],
+        [-1,0,3,1,1,1],
+        [-1,0,1,4,2,2],
+        [-1,0,1,2,5,3],
+        [-1,0,1,2,3,6]
+    ]
+
+    b = [-4,1,5,8,10,11]
+
+    sor = Digiproc::Strategies::SorStrategy.new(a,b)
+    puts sor.calculate(w: 0.5, threshold: 0.000001)

data/examples/modulation_schemes/dpsk_freq_domain.rb

@@ -0,0 +1,119 @@
+# Show that PSK and DPSK modulated signals have the same bandwidth
+
+# Define DPSK encoding/decoding strategy
+dpsk_strategy = Digiproc::Strategies::XORDifferentialEncodingZeroAngleStrategy
+
+# *********** NOTE: Digiproc::Strategies::DifferentialEncodingStrategy encodes for an M-ary PSK signal, requires decoding
+# via reciever in figure 4-15 of INTRODUCITON TO DIGITAL COMMUNICATION, ZIEMER, PETERSON which has not been implemented.
+
+# Not adding a coding strategy into PSK causes bit to phase mapping to not be differentially encoded
+
+# Make a 100-bit stream, make one PSK (Phase Shift Keying) and one DPSK (Differential PSK) signal, plot the frequency domians
+
+signal2 = Digiproc::Probability::RandomBitGenerator.new_bitstream.generate(600).split('')
+psk2 = Digiproc::Strategies::PSK.new(modulating_signal: signal2, carrier_frequency: 10, pulse_length: 0.05)
+dpsk2 = Digiproc::Strategies::PSK.new(modulating_signal: signal2, coding_strategy: dpsk_strategy, carrier_frequency: 10, pulse_length: 0.05)
+
+puts "PSK Signal"
+puts "Coded"
+puts psk2.coded_signal.to_s
+puts "Phase"
+puts psk2.phase_signal.to_s
+
+
+puts "DPSK Signal"
+puts "Coded"
+puts dpsk2.coded_signal.to_s
+puts "Phase"
+puts dpsk2.phase_signal.to_s
+
+puts "Original signal:"
+puts "#{signal2}"
+puts "Decoded signal:"
+# NOTE: decoded signals are not simulating a reciever, but just reversing the coding strategy
+puts "DPSK"
+puts "#{dpsk2.decode}"
+puts "PSK"
+puts "#{psk2.decode}"
+puts "Match check"
+puts "DPSK decode matches original:"
+puts signal2 == dpsk2.decode
+puts "PSK decode matches original:"
+puts signal2 == psk2.decode.map{ |i| i.to_i.to_s }
+
+# Below simulates a receiver per fig. 4-14 in INTRODUCTION TO DIGITAL COMMUNICATIONS, ZIEMER, PETERSON
+# Reciever is of the form: phase signal -> Bandwidth Filter 0.57 / Tb -> Delay -> multiply -> Lowpass Filter -> Sample at t = Tb -> Output
+                                                                      #|-bypass-->{up_arrow}
+
+#Example below fails, if you have time and want to help troubleshoot, please contribute! First
+# 200 samples are showing up, and the rest seem to be wrapped in the front of the ifft. See 
+# Digiproc::Strategies::PSK#reciever_out for troubleshooting
+
+puts "Simulated DPSK reciever output:"
+receiver_out = dpsk2.reciever_decode
+puts receiver_out.to_s
+puts receiver_out.map{ |i| i.to_f <=> 0 }.map{ |i| i == -1 ? 0 : 1 }.to_s
+puts "Test equality of signal"
+test_sig =  receiver_out.map{ |i| (i.to_f <=> 0).to_s }.map{ |i| i == "-1" ? "0" : "1" } 
+
+# Note - this reciever only works for small signals at this time. 
+# The FFT funciton needs to be optimized to automatically set the appropriate size
+# based off of the input function 
+
+
+
+puts test_sig.size
+puts signal2.size
+puts test_sig == signal2
+puts test_sig == signal2.take(test_sig.length)
+
+test_sig.each_with_index do |sym, i| 
+    if test_sig[i] != signal2[i]
+        puts "Signal fails at index #{i}"
+        puts signal2[i - 10, 50].to_s
+        puts test_sig[i - 10, 50].to_s
+        break
+    end
+end
+
+path = "./examples/modulation_schemes/"
+
+Digiproc::QuickPlot.plot(data: psk2.output.to_ds.fft.magnitude, title: "PSK 2", path: path)
+Digiproc::QuickPlot.plot(data: dpsk2.output.to_ds.fft.magnitude, title: "DPSK 2", path: path)
+
+# Make 75 8-bit symbols, make one PSK and one DPSK signal, plot the frequency domians
+signal256 = Digiproc::Probability::RandomBitGenerator.new_symbol_stream(bits_per_symbol: Math.log(256,2).to_i).generate 75
+psk256 = Digiproc::Strategies::PSK.new(modulating_signal: signal256, carrier_frequency: 10, pulse_length: 0.4)
+dpsk256 = Digiproc::Strategies::PSK.new(modulating_signal: signal256, coding_strategy: dpsk_strategy ,carrier_frequency: 10, pulse_length: 0.4)
+s = signal256.map{|a| a.to_i(2)}
+
+puts "Original signal"
+puts s.to_s
+puts
+puts "DPSK Signal"
+puts "Coded"
+puts dpsk256.coded_signal.to_s
+puts "Phase"
+puts dpsk256.phase_signal.to_s
+puts
+puts "PSK Signal"
+puts "Coded"
+puts psk256.coded_signal.to_s
+puts "Phase"
+puts psk256.phase_signal.to_s
+
+Digiproc::QuickPlot.plot(data: psk256.output.to_ds.fft.magnitude, title: "PSK 256", path: path)
+Digiproc::QuickPlot.plot(data: dpsk256.output.to_ds.fft.magnitude, title: "DPSK 256", path: path)
+
+puts "Original Signal"
+puts "#{signal256}"
+
+puts "Decoded signal"
+puts "Decoded DPSK"
+puts "#{dpsk256.decode}"
+puts "Decoded PSK"
+puts "#{psk256.decode}"
+
+puts "Match check:"
+puts "#{signal256 == dpsk256.decode}"
+puts "#{signal256 == psk256.decode.map{ |i| i.to_i.to_s }}"

data/examples/modulation_schemes/psk.rb

@@ -0,0 +1,36 @@
+plt = Digiproc::QuickPlot
+
+sig_str = "110100010110"
+sig = sig_str.split('')
+diff_sig = Digiproc::Strategies::XORDifferentialEncodingStrategy.encode(sig, 2, "0")
+
+bpsk = Digiproc::Strategies::PSK.new(modulating_signal: diff_sig, coding_strategy: nil)
+bdpsk = Digiproc::Strategies::PSK.new(modulating_signal: sig)
+dpsk = Digiproc::Strategies::PSK.new(modulating_signal: sig, coding_strategy: Digiproc::Strategies::DifferentialEncodingStrategy)
+
+puts "System 1 Differential Signal: #{bpsk.coded_signal}"
+puts "System 1 Phase: #{bpsk.phase_signal.map{ |ps| ps / Math::PI }} * pi"
+puts "System 1 Decoded: #{bpsk.decode}"
+plt.plot(data: bpsk.phase_signal.map{ |p| p / Math::PI}, y_label: "Phase", title: "System 1 Phase")
+puts "\n\n"
+puts "System 2 Differential Signal: #{bdpsk.coded_signal}"
+puts "System 2 Coded Phase: #{bdpsk.phase_signal.map{ |ps| ps / Math::PI}} * pi"
+puts "System 2 Decoded: #{bdpsk.decode}"
+plt.plot(data: bdpsk.phase_signal.map{ |p| p / Math::PI},y_label: "Phase", title: "System 2 Phase")
+puts "\n\n"
+
+puts "System 3 Signal: #{dpsk.coded_signal}"
+puts "System 3 Coded Phase: #{dpsk.phase_signal.map{ |p| p / Math::PI}} * pi"
+puts "System 3 Decoded: #{dpsk.decode}"
+plt.plot(data: dpsk.phase_signal.map{ |p| p / Math::PI},y_label: "Phase", title: "System 3 Phase")
+puts "\n\n"
+
+# dpsk_output = dpsk.output
+# time_range = Digiproc::Functions.linspace(0, dpsk_output.sample_rate * dpsk_output.size, dpsk_output.size)
+path = "./examples/modulation_schemes/"
+plt.plot(data: bpsk.output.digitize, title: "System 1 Xmit Signal", y_label: "Magnitude", dark: true, path: path)
+plt.plot(data: bdpsk.output.digitize, title: "System 2 Xmit Signal", y_label: "Magnitude", dark: true, path: path)
+plt.plot(data: dpsk.output.digitize, title: "System 3 Xmit Signal", y_label: "Magnitude", dark: true, path: path)
+puts "System 1 Output From Reciever: \n#{bpsk.reciever_decode}\n\n"
+puts "System 2 Output From Reciever: \n#{bdpsk.reciever_decode}\n\n"
+puts "System 3 Output From Reciever: \n#{dpsk.reciever_decode}\n\n"

data/examples/quickplot/decorators.rb

@@ -0,0 +1,13 @@
+# DISREGARD THIS EXAMPLE
+
+#Using Gruff Line
+
+#Below does not work, needs to be re-worked
+
+
+g = Gruff::Line.new('1000x1000')
+distr = Digiproc::Probability::RealizedGaussianDistribution.new(mean: 0, stddev: 3, size: 100)
+g.data :random, distr.data
+gnew = Digiproc::Plottable::ClassMethods::VerticalLine.new(g, 30)
+gnew.write('./examples/quickplot/test.png')
+

data/examples/quickplot/quickplot_vs_others.rb

@@ -0,0 +1,85 @@
+# Use gruff directly
+g = Gruff::Line.new('1000x1000')
+distr = Digiproc::Probability::GaussianDistribution.new(mean: 0, stddev: 3, size: 100)
+g.data("Random data", distr.data)
+g.write('./examples/quickplot/direct_gruff.png')
+
+path = "./examples/quickplot/"
+
+
+# Using QuickPlot
+
+plt = Digiproc::QuickPlot
+plt.plot(title: "Random data QuickPlot", data: distr.data, path: path, data_name: "Random distr.")
+plt.plot(title: "Random data QuickPlot, dark", data: distr.data, path: path, x_label: "x axis", y_label: "y axis",dark: true)
+
+
+
+
+
+# Using Plottable Module inside a class
+
+    # Big advantage of not using QuickPlot is the ability to use xsteps as a parameter which specifies the label
+    # interval on the x axis of the plot
+class PlottableClass 
+
+    extend Digiproc::Plottable::ClassMethods
+    include Digiproc::Plottable::InstanceMethods
+
+    def initialize(distr)
+        @distr = distr
+    end
+
+    def data
+        return @distr.data
+    end
+
+end
+
+plot = PlottableClass
+
+plot.qplot(data: distr.data, data_name: "Random distribution",xsteps: 10, path: path) do |g|
+    g.title = "Random Data Plottable qPlot"
+    g.x_axis_label = "x axis"
+    g.y_axis_label = "y axis"
+end
+
+plot_instance = PlottableClass.new(distr)
+
+# Instnace Methods includes qplot which is the same as above
+# plot used below should be renamed to fftPlot() - it was created to plot
+# a Discrete Fourier Transform - the x axis goes from 0 to 1 regardless of 
+# points in the dataset to correspond to normalized frequency in a DFT plot.
+
+plot_instance.plot(method: :data, xsteps: 10, path: path) do |g|
+    g.title = "Random Data from Instance Method"
+    g.x_axis_label = "x axis"
+    g.y_axis_label = 'y axis'
+end
+
+
+## You can use Digiproc::Plottable class methods as well: (TODO)
+
+
+
+## Using Rbplot
+
+x = Digiproc::Functions.linspace(1,100,100)
+y1 = Digiproc::Probability.nrand(100)
+y2 = Digiproc::Probability.nrand(100)
+
+plt = Digiproc::Rbplot.line(x,y1)
+plt.size(2000,2000)
+plt.title('Test title')
+plt.xlabel('x axis')
+plt.ylabel('y axis')
+plt.xsteps(10)
+plt.add_line(x, y2)
+plt.add_line(x,x.map{ |a| a / 100})
+plt.theme(:light)
+plt.legend('set1', 'set2', 'set3')
+plt.show
+plt.title('Test title dark')
+plt.theme(:dark)
+plt.show
+

data/examples/realized_gaussian/realized_gaussian_example.rb

@@ -0,0 +1,23 @@
+plt = Dsp::QuickPlot
+gauss = Dsp::Probability::RealizedGaussianDistribution
+fns = Dsp::Functions
+
+distribution = gauss.new(mean: 0, stddev: 10, size: 100)
+data = distribution.data
+
+#qplot function in quickplot gives a different plot API
+plt.qplot(data: data, path: './examples/realized_gaussian/', filename: 'norm_dist_plot', xsteps: 10, data_name: "normal random numbers") do |g|
+    g.title = "Gaussian Random Numbers"
+    g.theme = Dsp::Plottable::Styles::MIDNIGHT
+    g.show_vertical_markers = false
+end
+
+spectra = fns.fft(data).map(&:abs)
+x_vals = fns.linspace(0,128,128)
+
+plt.qplot(data: spectra, path: './examples/realized_gaussian/', filename: 'norm_dist_spectrum', xsteps: 4, xyname: "spectra mag. of norm. random nums") do |g|
+    g.title = "Gaussian Nums: Frequency Domain"
+    g.labels = {0 => 0, 32 => 0.25, 64 => 0.5, 98 => 0.75, 127 => 1}
+    g.show_vertical_markers = false
+end
+

data/lib/concerns/convolvable.rb

@@ -0,0 +1,144 @@
+
+module Digiproc::Convolvable
+
+
+    ## 
+    # This module contains class methods for performing convolution based off a strategy. Digiproc::Convolvable 
+    # extends ClassMethods, and therefore all methods can be called on the Convolable module.
+    # Note that arrays in this module must be of Numeric types
+ 
+    module ClassMethods
+        ## 
+        ## convolve(data1 [Array], data2 [Array], strategy [ConvolutionStrategy]) => returns Array[Numeric]
+        # This method performs convolution.
+        # `strategy` can be custom-written as long as it matches the ConvolutionStrategy interface: 
+        # have a class method called `conv` which takes 2 arrays and convolves them. ie: 
+        ## Digiproc::Convolvable.conv([1,2,3],[1,2,3]) #=> [1, 4, 10, 12, 9]
+
+        def convolve(data1, data2, strategy = Digiproc::Strategies::BFConvolutionStrategy)
+            strategy.conv(data1, data2, strategy)
+        end
+
+        ## 
+        # Alias to #convolve
+        def conv(data1, data2, strategy = Digiproc::Strategies::BFConvolutionStrategy) 
+            strategy.conv(data1,data2)
+        end
+
+        ## 
+        ## cross_correlation(data1 [Array], data2 [Array]) => returns Array[Numeric]
+        # Uses the #conv method to perform cross_correlation by reversing the second data set order
+        # Does not accept a strategy as a third parameter
+        ## Digiproc::Convolvable.cross_correlation(arr1, arr2)
+        def cross_correlation(data1, data2)
+            conv(data1, data2.reverse)
+        end
+
+        ## 
+        # Alias to #cross_correlation
+        def xcorr(data1, data2)
+            cross_correlation(data1, data2)
+        end
+
+        ## 
+        ## auto_correlation(data [Array]) => returns Array[Numeric]
+        # Uses the cross_correlation method to perform cross correlation of data on itself.
+        ## Digiproc::Convolvable.auto_correlation([1,2,3]) # => [3, 8, 14, 8, 3]
+        def auto_correlation(data)
+            cross_correlation(data, data)
+        end
+
+
+        ## 
+        # Alias to #auto_correlation
+        # ie: 
+        ## Digiproc::Convolvable.acorr([1,2,3]) # => [3, 8, 14, 8, 3]
+        def acorr(data)
+            cross_correlation(data, data)
+        end
+
+    end
+
+    ## 
+    # This module contains instance methods for classes which have properties of `data` which 
+    # are arrays and can undergo convolution, correlation, cross-correlation, and autocorrelation (arrays must then be of Numerics). As such, if 
+    # a class `includes` Convolvable::InstanceMethods, it is also including `Digiproc::RequiresData` which ensures that the
+    # class has a `data` property
+
+    module InstanceMethods
+
+        ## 
+        # When included in a class, it automatically has that class include Digiproc::RequiresData, because methods in this module require that there be a property called `data` which is an Array
+        def self.included(base)
+            base.class_eval do 
+                include Digiproc::RequiresData
+            end
+        end
+
+        ## 
+        # Optionally initializable with a `ConvolutionStrategy` (see `Digiproc::Initializable`)
+        # This snows up as new, but when using this code, :initialize will be called. This pattern is utilized in the Digiproc::DigitalSignal class, and can be seen in its initializer.
+        def initialize(strategy: Digiproc::Strategies::BFConvolutionStrategy)
+            @convolution_strategy = strategy
+        end
+
+        ## 
+        ## convolve(incoming_data [Array [OR a class including Digiproc::RequiresData]]) => returns Array[Numeric]
+        # uses the `strategy` class to convolve the included class' data property with the array provided as an argument
+        # ie if class DataHolder includes Convolavable::InstanceMethods, and you have two instances, d1 and d2, you can say: 
+        ## d1.convolve(d2)
+        # Or, if you have a 1D array of numerics in variable `my_data_arr` capable of convolving with d1.data, you can say:
+        ## d1.convolve(my_data_arr) # returns array of data
+        def convolve(incoming_data)
+            incoming_data = incoming_data.is_a?(Array) ? incoming_data : incoming_data.data
+            self.convolution_strategy.conv(self.data, incoming_data)
+        end
+
+        ## 
+        # Alias to convolve
+        def conv(incoming_data)
+            self.convolve(incoming_data)
+        end
+
+        ## 
+        # Used internally to ensure that if the class which includes this module is not `Initializable`, then a Convolution strategy will still be set
+        # In this case, use Digiproc::BFConvolutionStrategy
+        def convolution_strategy
+            @convolution_strategy.nil? ? Digiproc::Strategies::BFConvolutionStrategy : @convolution_strategy
+        end
+
+        ## 
+        ## cross_correlation(incoming_data [Array [OR a class extending Digiproc::RequiresData]]) => returns Array[Numeric]
+        # see #convolve for example of using an array or a Digiproc::RequiresData. ie: 
+        ## includingInstance.cross_correlation(array_data) # returns array of data
+        def cross_correlation(incoming_data)
+            incoming_data = incoming_data.is_a?(Array) ? incoming_data : incoming_data.data
+            self.convolution_strategy.conv(self.data, incoming_data.reverse)
+        end
+
+        ## 
+        # Alias to cross_correlation
+        def xcorr(incoming_data)
+            self.cross_correlation(incoming_data)
+        end
+
+        ## 
+        ## auto_correlation() => returns Array[Numeric]
+        # Performs autocorrelation of self.data ie:
+        ## includingInstance.auto_correlation # returns array of data
+        def auto_correlation
+            self.cross_correlation(self.data)
+        end
+
+        ## 
+        # Alias to auto_correlation
+        def acorr
+            self.cross_correlation(self.data)
+        end
+
+
+    end
+
+    extend self::ClassMethods
+
+end