digiproc 0.1.0

data/examples/analog_signals/companding.rb

@@ -0,0 +1,68 @@
+eqn1 = ->(t){ 8 * Math.cos(20 * Math::PI * t) }
+eqn2 = ->(t){ Math.cos(20 * Math::PI * t) }
+rate = 1.0 / 51.0
+
+x1 = Digiproc::AnalogSignal.new(eqn: eqn1, sample_rate: rate, size: 6, quantization_bits: 4, quant_max: 8, quant_min: -8)
+x2 = Digiproc::AnalogSignal.new(eqn: eqn2, sample_rate: rate, size: 6, quantization_bits: 4, quant_max: 8, quant_min: -8)
+
+compression_eqn = ->(n){ n < 0 ? (-4 * ((-n) ** (1.0 / 3))) : (4 * n ** (1.0 / 3))}
+expansion_eqn =->(n){ n < 0 ? ((-1.0 / 64) * ((-n) ** 3)) : ((1.0 / 64) * n ** 3)}
+
+compander = Digiproc::Strategies::CustomCompandingStrategy.new(compression_eqn, expansion_eqn)
+
+x3 = Digiproc::AnalogSignal.new(eqn: eqn1, sample_rate: rate, size: 6, quantization_bits: 4, quant_max: 8, quant_min: -8, companding_strategy: compander)
+x4 = Digiproc::AnalogSignal.new(eqn: eqn2, sample_rate: rate, size: 6, quantization_bits: 4, quant_max: 8, quant_min: -8, companding_strategy: compander)
+
+puts "x(1): "
+puts x1.digitize.to_s
+puts "Raw samples: #{x1.raw_samples}"
+puts "Normalized Quantization RMS Error: #{x1.normalized_quantization_rms_error.round(3)}"
+puts "\n\nx(2):"
+puts x2.digitize.to_s
+puts "Raw samples: #{x2.raw_samples}"
+puts "Normalized Quantization RMS Error: #{x2.normalized_quantization_rms_error.round(3)}"
+puts "\n\nx(1) with companding: "
+puts x3.digitize.to_s
+puts "Raw samples: #{x3.raw_samples}"
+puts "Normalized Quantization RMS Error: #{x3.normalized_quantization_rms_error.round(3)}"
+puts "\n\nx(2) with companding:"
+puts x4.digitize.to_s
+puts "Raw samples: #{x4.raw_samples}"
+puts "Normalized Quantization RMS Error: #{x4.normalized_quantization_rms_error.round(3)}"
+# binding.pry
+
+signal = ->(t){Math.cos(2 * Math::PI * t)} #cos at 1 Hz
+sample_times = (0..1000).map{ |int| int / 100.0} #Sample for 10 seconds every 0.01 seconds (100 times per period over 10 periods)
+data = sample_times.map{ |time| signal.call(time) }
+ft = []
+for k in 0...data.length do
+    tot = 0
+    data.each_with_index do |x_n, n|
+        tot += x_n * Math::E ** (Complex(0,-1) * 2.0 * Math::PI * k * n / data.length.to_f)
+    end
+    ft << tot
+end
+
+fft = Digiproc::FFT.new(time_data: data)
+t = Digiproc::Functions.linspace(0,1,fft.size)
+
+
+
+
+plt = Digiproc::Rbplot.line(t, fft.dB, "discrete frequency")
+plt.title('FFT Plot')
+plt.path('./examples/analog_signals/')
+plt.xlabel('Radians')
+plt.ylabel('Decibles')
+plt.xsteps(10)
+plt.show
+
+x = Digiproc::Functions.linspace(0, 6.0/51, 6)
+plt = Digiproc::Rbplot.line(x, x1.digitize, 'x1')
+plt.add_line(x, x2.digitize, 'x2')
+plt.add_line(x, x3.digitize, 'x1 companded')
+plt.add_line(x, x4.digitize, 'x2 companded')
+plt.path('./examples/analog_signals/')
+plt.title('Companded Signals')
+plt.ylabel('Magnitude')
+plt.show

data/examples/analog_signals/quantize_compand.rb

@@ -0,0 +1,69 @@
+# For the signals:
+# x1(t)=8cos(20πt)
+# x2(t)=cos(20πt)
+
+# Find Normalized Quantization RMS Error:
+
+# AnalogSignal class accepts an equation, sample rate, and size. Quantization bits, quantization max and min values, and a companding equation are optional.
+# Once the #digitize method is called on the initialized class:
+# The digital signal is sampled at the given sample rate for the given size number of samples
+# If a companding strategy is given, the compression of bits is applied to the samples
+# If a number of quantization bits are inputted, the values are quantized based on the number of bits desired as well as the max and min quantization values passed in.
+# To perform the quantization, you can follow the progression which starts in the #quantize method. First, the samples are mapped from the passed in max and min values to −1⟺+1 Then, the value is multiplied by the number of bits squared divided by 2. That value is rounded to the nearest integer, and then mapped back down to the original max and min values.
+# After quantization, if a companding strategy was given, the quantized samples are run through the expansion algorithm.
+# This leaves you with the final answer, which is returned from the #digitize method
+# The normalized RMS Error average value is calculated in the #normalized_quantization_rms_error method and is done so via the original sample values and the quantized output of the #digitize method.
+
+
+x1 = Digiproc::AnalogSignal.new(eqn: ->(t){ 8 * Math.cos(20 * Math::PI * t) }, sample_rate: 1.0 / 51.0, size: 6,quantization_bits: 4, quant_max: 8, quant_min: -8)
+x2 = Digiproc::AnalogSignal.new(eqn: ->(t){  Math.cos(20 * Math::PI * t) }, sample_rate: 1.0 / 51.0, size: 6,quantization_bits: 4, quant_max: 8, quant_min: -8)
+puts "x(1): "
+x1.digitize
+puts "Normalized Quantization RMS Error: #{x1.normalized_quantization_rms_error.round(3)}"
+puts "\n\nx(2):"
+x2.digitize
+puts "Normalized Quantization RMS Error: #{x2.normalized_quantization_rms_error.round(3)}"
+puts
+puts "x1 raw samples: #{x1.raw_samples.map{|s| s.round(2)}}"
+puts "x1 quantized samples: #{x1.quantized_samples}"
+
+puts 
+
+puts "x2 raw samples: #{x2.raw_samples.map{|s| s.round(2)}}"
+puts "x2 quantized samples: #{x2.quantized_samples}"
+
+
+# Now use a compander to attempt to reduce Quantization error:
+
+
+compression_eqn = ->(n){ n < 0 ? (-4 * ((-n) ** (1.0 / 3))) : (4 * n ** (1.0 / 3))}
+expansion_eqn =->(n){ n < 0 ? ((-1.0 / 64) * ((-n) ** 3)) : ((1.0 / 64) * n ** 3)}
+compander = Digiproc::Strategies::CustomCompandingStrategy.new(compression_eqn, expansion_eqn)
+ 
+
+x1 = Digiproc::AnalogSignal.new(eqn: ->(t){ 8 * Math.cos(20 * Math::PI * t) }, sample_rate: 1.0 / 51.0, size: 6,quantization_bits: 4, quant_max: 8, quant_min: -8, companding_strategy: compander)
+x2 = Digiproc::AnalogSignal.new(eqn: ->(t){  Math.cos(20 * Math::PI * t) }, sample_rate: 1.0 / 51.0, size: 6,quantization_bits: 4, quant_max: 8, quant_min: -8, companding_strategy: compander)
+ 
+
+puts "\n\nx(1) with companding: "
+
+x1.digitize
+
+puts "Normalized Quantization RMS Error: #{x1.normalized_quantization_rms_error.round(3)}"
+
+
+puts "\n\nx(2) with companding:"
+
+x2.digitize
+
+puts "Normalized Quantization RMS Error: #{x2.normalized_quantization_rms_error.round(3)}"
+
+puts "x3 raw samples: #{x1.raw_samples.map{|s| s.round(2)}}"
+puts "x1 quantized samples: #{x1.quantized_samples}"
+
+puts 
+
+puts "x2 raw samples: #{x2.raw_samples.map{|s| s.round(2)}}"
+puts "x2 quantized samples: #{x2.quantized_samples}"
+
+puts "Companding then reduced Quantization error for the low-amplitude signal x2, but raised it for the higher-amplitude signal x1"

data/examples/binomial_distribution/bit_error.rb

@@ -0,0 +1,14 @@
+#If a word consists of 10 bits with the ability to detect and correct any single bit error 
+# but not multiple bit errors, what is the probability of a word being in error? 
+# Compare the reduction in probability of a word error by using the error correcting code.
+
+# Given that P(error)=0.00135, as it would be for a +- 1V signal with additive white gaussian noise
+# with a variance of 1/9:
+
+
+bd = Digiproc::Probability::TheoreticalBinomialDistribution.new(n: 10, p: 0.00135)
+puts "Probability of no errors: #{bd.probability(0)}"
+puts "Probability of one error: #{bd.probability(1)}"
+puts "Probability of one or more errors(if no code fix): #{bd.probability(1..10)}"
+puts "Probability of two or more errors (prob after code fix): #{bd.probability(2..10)}, should equal #{1 - bd.probability(0,1)}"
+puts "Reduction in error by using error correcting code: #{bd.probability(1..10) - bd.probability(2..10)}"

data/examples/binomial_distribution/dice.rb

@@ -0,0 +1,35 @@
+binomial_dist = Digiproc::Probability::TheoreticalBinomialDistribution
+
+six_die_roll = binomial_dist.new(n: 6, p: (1.0/6))
+
+puts "For six die rolls:"
+
+puts "At least one of a specific number: #{1 - (1 - (1.0/6)) ** 6}"
+puts "Same as above with binomial dist: #{six_die_roll.probability(1..6)}"
+puts "-------------------------------"
+puts "Six of a kind: #{1 - ((six_die_roll.probability(0..5)) ** 6)}"
+puts "At least 5 of a kind: #{1 - ((six_die_roll.probability(0..4)) ** 6)}"
+puts "At least 3 of a predetermined number: #{six_die_roll.probability(3..6)}"
+puts "-------------------------------"
+
+puts "Experimental Data"
+
+at_least = 3
+die_number = 3
+count = 0
+r = Random.new
+total = 5000000
+total.times do 
+    rolls = {1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0}
+    6.times do
+        num = r.rand(6) + 1
+        rolls[num] += 1
+        if rolls[die_number] == at_least
+            count += 1
+            break
+        end
+    end
+end
+
+puts "At least #{at_least} #{die_number}s (experimental data): #{count / total.to_f}"
+

data/examples/digital_signals/modulate_square_pulses.rb

@@ -0,0 +1,9 @@
+
+input_data = Array.new(10,0) + Array.new(10,1) + Array.new(20,0) + Array.new(20,1) + Array.new(40,0)
+x_n = Digiproc::DigitalSignal.new(data: input_data)
+lpf = Digiproc::Factories::FilterFactory.filter_for(type: 'lowpass', wc: Math::PI / 10, transition_width: 0.01, stopband_attenuation: 80).to_ds
+carrier = Digiproc::DigitalSignal.new_from_eqn(eqn: ->(n){Math.cos(10.0 * 2.0 * Math::PI * n / 100) }, size: lpf.data.length)
+y_n =  Digiproc::DigitalSignal.new(data: (x_n.fft(2**8) * lpf.fft(2**8)).ifft.map(&:real).take(100)) * carrier * carrier
+y_n_alt = x_n.ds_conv(lpf) * carrier * carrier
+Digiproc::QuickPlot.plot(data: y_n.data, title: "Modulated Sq. Pulses", path: './examples/digital_signals/')
+Digiproc::QuickPlot.plot(data: y_n_alt.data[274,100], title: "Modulated Sq. Pulses Alt", path: './examples/digital_signals/')

data/examples/digital_signals/square_signals.rb

@@ -0,0 +1,90 @@
+# Define required objects and constants
+r = Random.new
+pulse_lens = [1,2]
+plt = Digiproc::QuickPlot
+fns = Digiproc::Functions
+a = 1
+
+# Random signal generator functions
+def get_signal(rand_gen, a = 1)
+    rand_gen.rand(2) == 0 ? -a : a
+end
+
+# Create signal data
+signal_size = 400
+sample_rate = 0.05
+signal_arr = []
+signal_size.times { signal_arr << get_signal(r, a)}
+
+#Get results with varied pulse length
+pulse_lens.each do |pulse_len|
+    size = (1.0 / sample_rate) * signal_size * pulse_len
+    # Correct for sample rate so it can be compared to CT equation
+    signal_eqn = ->(t){ signal_arr[(t / pulse_len.to_f).floor] * sample_rate }
+    signal = Digiproc::AnalogSignal.new(eqn: signal_eqn, sample_rate: sample_rate, size: size)
+    freq_of_interest1 = 1.0 / (2 * pulse_len)
+    freq_of_interest2 = 1.0 / ( pulse_len)
+    # Test calculated equation 
+    x_f = Proc.new do |f|
+        signal_arr.map.with_index{ |s, n| s.to_f * (a / (Complex(0, f * 2 * Math::PI))) * (Math::E ** (Complex(0, -f * Math::PI * 2 * n * pulse_len)) - Math::E ** (Complex(0,-f * 2 * Math::PI * pulse_len) * (1 + n))) }.sum
+    end
+    max_freq = 0.5 / (sample_rate)
+    freq_space = fns.linspace(0, max_freq, size)
+    xf_plot = fns.process(freq_space, x_f).map(&:abs)
+    #Equation DNE @ omega = 0
+    xf_plot[0] = 0
+
+    foi1_from_eqn = ((freq_of_interest1.to_f / max_freq) * xf_plot.length).to_i
+    foi2_from_eqn = ((freq_of_interest2.to_f / max_freq) * xf_plot.length).to_i
+
+    
+    puts "Magnitude at 1/2T : #{xf_plot[foi1_from_eqn]}"
+    puts "Magnitude at 1/T  : #{xf_plot[foi2_from_eqn]}"
+    puts
+    
+    # Plot output from derived equation
+    plt.plot(data: xf_plot, title: "Freq Sig from Eqn, Ts = #{pulse_len} s", path: "./examples/digital_signals/")
+
+    # Plot experiment data
+    plt.plot(data: signal.digitize, title: "Time signal, Ts = #{pulse_len} s", path: "./examples/digital_signals/")
+    plt.plot(data: signal.to_ds.fft.magnitude, title: "Frequency Signal, Ts = #{pulse_len} s", path: "./examples/digital_signals/")
+    plt.plot(data: signal.to_ds.psd.data.map(&:real), title: "Power Spectral Density,  Ts = #{pulse_len} s", path: "./examples/digital_signals/")
+end
+
+puts
+puts 
+
+alpha = 1
+coded_arr = Array.new(signal_size, 0)
+coded_arr[0] = signal_arr.first
+for i in 1...signal_size do
+    coded_arr[i] = signal_arr[i] + alpha * signal_arr[i-1]
+end
+
+pulse_lens.each do |pulse_len|
+    size = (1.0 / sample_rate) * signal_size * pulse_len
+    signal_eqn = ->(t){ coded_arr[(t / pulse_len.to_f).floor] * sample_rate }
+    signal = Digiproc::AnalogSignal.new(eqn: signal_eqn, sample_rate: sample_rate, size: size)
+    freq_of_interest1 = 1.0 / (2 * pulse_len)
+    freq_of_interest2 = 1.0 / ( pulse_len)
+
+    x_f = Proc.new do |f|
+        coded_arr.map.with_index{ |s, n| s.to_f * (a / (Complex(0, f * 2 * Math::PI))) * (Math::E ** (Complex(0, -f * Math::PI * 2 * n * pulse_len)) - Math::E ** (Complex(0,-f * 2 * Math::PI * pulse_len) * (1 + n))) }.sum
+    end
+    max_freq = 0.5 / (sample_rate)
+    freq_space = fns.linspace(0, max_freq, size)
+    xf_plot = fns.process(freq_space, x_f).map(&:abs)
+    xf_plot[0] = 0
+    # freq_unit = size.to_f / max_freq
+    foi1_from_eqn = ((freq_of_interest1.to_f / max_freq) * xf_plot.length).to_i
+    foi2_from_eqn = ((freq_of_interest2.to_f / max_freq) * xf_plot.length).to_i
+    # puts signal.to_ds.fft.magnitude[(foi1_from_eqn / 2 - 1).to_i]
+    puts "Coded Magnitude at 1/2T : #{xf_plot[foi1_from_eqn]}"
+    puts "Coded Magnitude at 1/T  : #{xf_plot[foi2_from_eqn]}"
+    plt.plot(data: xf_plot, title: "Coded Freq Sig from Eqn, Ts = #{pulse_len} s")
+    
+    #Plot test data
+    plt.plot(data: signal.digitize, title: "Coded Time signal, Ts = #{pulse_len} s", path: "./examples/digital_signals/")
+    plt.plot(data: signal.to_ds.fft.magnitude, title: " Coded Frequency Signal, Ts = #{pulse_len} s", path: "./examples/digital_signals/")
+    plt.plot(data: signal.to_ds.psd.data.map(&:real), title: "Coded Power Spectral Density,  Ts = #{pulse_len} s", path: "./examples/digital_signals/")
+end

data/examples/encoding/gray_code.rb

@@ -0,0 +1,22 @@
+## Gray code maps "normal" numbers to a binary code in which adjacent numbers
+## only change by one bit. This reduced errors in the whole number when you 
+## there is an error decoding a single bit
+
+gc_gen = Digiproc::Strategies::GrayCode
+
+
+three_bit_gray_code = gc_gen.generate(3)
+
+puts three_bit_gray_code.to_s
+puts "In decimal:"
+gray_dec = three_bit_gray_code.map{ |gc| gc.to_i(2) }
+puts gray_dec.to_s
+
+
+puts "decode:"
+puts "map gray code back to its original number"
+
+orig_dec = gray_dec.map{ |dec| gc_gen.to_dec(dec) }
+puts orig_dec.to_s
+
+puts orig_bin = gray_dec.map{ |dec| gc_gen.to_binary(dec)}.to_s

data/examples/encoding/psk.rb

@@ -0,0 +1,91 @@
+# We want to transmit the data sequence 110100010110 using binary DPSK. 
+# Let s(t)=Acos(2πfot+θ) represent the transmitted signal in a signaling interval of duration Tb. 
+# Give the phase of the tranmitted signal. Begin with θ=0 for the phase of the first bit to be transmitted.
+
+
+ 
+sig_str = "110100010110"
+sig = sig_str.split('')
+# diff_sig = Digiproc::Strategies::XORDifferentialEncodingStrategy.encode(sig, 2, "0")
+ 
+# System 1: 
+#Use XOR to encode original signal with a delayed version of itself
+# Map bits 0 => 0 rad, 1 => pi rad
+bpsk = Digiproc::Strategies::PSK.new(modulating_signal: sig, coding_strategy: Digiproc::Strategies::XORDifferentialEncodingZeroAngleStrategy)
+
+# System 2:
+# Use XOR to encode original signal with a delayed version of itself
+# Map bits 0 => pi, 1 => 3pi/2
+bdpsk = Digiproc::Strategies::PSK.new(modulating_signal: sig, coding_strategy: Digiproc::Strategies::XORDifferentialEncodingStrategy)
+
+# System 3: 
+# Do not XOR the bits but instead map them directly into frequencies which then are added to dealyed versions
+# of themselves modulo 2pi (see the strategy used for more details)
+dpsk = Digiproc::Strategies::PSK.new(modulating_signal: sig, coding_strategy:Digiproc::Strategies::DifferentialEncodingStrategy)
+
+#System 4:
+# Directly maps bits to phase without XORing and does not alter phase angles at all for transmission
+dpsk2 = Digiproc::Strategies::PSK.new(modulating_signal: sig) 
+
+xvals = Digiproc::Functions.linspace(1,sig_str.length, sig_str.length + 1)
+
+
+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}"
+
+dpskvals = bpsk.phase_signal.map{ |p| p / Math::PI}
+path = "./examples/encoding/"
+plt = Digiproc::Rbplot.line(xvals, dpskvals)
+plt.xlabel("sample number")
+plt.ylabel("phase ( *pi rad )")
+plt.title("XOR DPSK Phase Signal (Sys1)")
+plt.legend("DPSK angle")
+plt.show(path)
+
+qplt = Digiproc::QuickPlot
+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}"
+qplt.plot(data: bdpsk.phase_signal.map{ |p| p / Math::PI},y_label: "Phase", title: "System 2 Phase", path: path)
+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}"
+puts "(This is not correct)"
+qplt.plot(data: dpsk.phase_signal.map{ |p| p / Math::PI},y_label: "Phase", title: "System 3 Phase", path: path)
+puts "\n\n"
+ 
+
+puts "System 4 Signal: #{dpsk2.coded_signal}"
+puts "System 4 Coded Phase: #{dpsk2.phase_signal.map{ |p| p / Math::PI}} * pi"
+puts "System 4 Decoded: #{dpsk2.decode}"
+qplt.plot(data: dpsk2.phase_signal.map{ |p| p / Math::PI},y_label: "Phase", title: "System 3 Phase", path: path)
+puts "\n\n"
+
+
+yvals = bpsk.output.digitize 
+xvals = Digiproc::Functions.linspace(1,yvals.length, yvals.length)
+plt = Digiproc::Rbplot.line(xvals, yvals)
+plt.title("XOR DPSK Xmit Signal (Sys 1)")
+plt.xlabel("Sample number")
+plt.ylabel("Signal Amplitude")
+plt.legend("DPSK Xmit Signal")
+plt.theme(:dark)
+plt.show(path)
+
+
+qplt.plot(data: bdpsk.output.digitize, title: "System 2 Xmit Signal", y_label: "Magnitude", dark: true, path: path)
+qplt.plot(data: dpsk.output.digitize, title: "System 3 Xmit Signal", y_label: "Magnitude", dark: true, path: path)
+qplt.plot(data: dpsk2.output.digitize, title: "System 4 Xmit Signal", y_label: "Magnitude", dark: true, path: path)
+
+puts "System 1 Output From Reciever: \n#{bpsk.reciever_decode}\n\n"
+puts "Correctly decoded by reciever \n"
+puts "System 2 Output From Reciever: \n#{bdpsk.reciever_decode}\n\n"
+puts "Correctly decoded by reciever \n"
+puts "System 3 Output From Reciever: \n#{dpsk.reciever_decode}\n\n"
+puts "Not properly decoded by reciever"
+puts "System 4 Output From Reciever: \n#{dpsk2.reciever_decode}\n\n"
+puts 'Not properly decoded by reciever'

data/examples/factories/bandpass.rb

@@ -0,0 +1,6 @@
+Filter_factory = Digiproc::Factories::FilterFactory
+plt = Digiproc::QuickPlot
+bpfilter = Filter_factory.filter_for(type: "bandpass", wo: Math::PI / 3, bw: Math::PI / 10, transition_width: 0.1, stopband_attenuation: 80)
+freq_db = bpfilter.fft.dB
+# Get x values with the linspace function (start, stop, number_of_points)
+plt.plot(x: Digiproc::Functions.linspace(0,1,freq_db.length) ,y: freq_db, y_label: "dB", dark: true, path: './examples/factories/')

data/examples/fft/simple_fft_example.rb

@@ -0,0 +1,47 @@
+plt = Digiproc::QuickPlot
+prob = Digiproc::Probability
+norm_dist = Digiproc::Probability::RealizedGaussianDistribution
+window = BlackmanWindow.new(size: 16384)
+
+#************ Find a signal in noise with FFT ****************
+
+#sample every 1 ms
+sample_rate = 0.001
+datapoints = 16384 # use a power of 2 because FFT uses Radix 2 algorithm
+#300Hz and 500Hz signals
+signal = Digiproc::AnalogSignal.new(eqn: ->(t){0.2 * Math.cos(2*Math::PI * 300 * t) + 0.3 * Math.cos(2 * Math::PI * 400 * t)}, sample_rate: sample_rate, size: datapoints).to_ds
+data = signal.data
+noise = norm_dist.new(mean: 0, stddev: 1, size: datapoints)
+#Add signal to noise data
+recieved_signal = data.plus(noise.data)
+
+#process signal with a blackman window (below shows that this is an optional step)
+processed_signal_data = recieved_signal.times window.data
+
+processed_signal = Digiproc::DigitalSignal.new(data: processed_signal_data)
+
+fft = processed_signal.fft
+
+#Get the 
+signal_locations = fft.maxima(4)
+
+puts signal_locations
+
+max_freq_hz = 0.5 / sample_rate
+max_freq_datapoint = datapoints / 2
+
+# Only use signals below Nyquist Frequency
+signal_locations.select!{ |location| location.index < max_freq_datapoint }
+
+signal_1_freq = signal_locations[0].index.to_f / max_freq_datapoint * max_freq_hz
+signal_2_freq = signal_locations[1].index.to_f / max_freq_datapoint * max_freq_hz
+
+puts "Most powerful signal at #{signal_1_freq} Hz"
+puts "Second most powerful signal at #{signal_2_freq} Hz"
+
+#Signal not viewable in time domain
+plt.plot(data: recieved_signal, title: "Recieved data (time domain)", path: './examples/fft/' )
+#Signal easily viewed in frequency domain (dB plot)
+fft.plot_db(path: "./examples/fft/")
+#plot unprocessed signal dB
+plt.plot(data: Digiproc::DigitalSignal.new(data: recieved_signal).fft.dB , title: "Unprocessed FFT", path: './examples/fft/')

data/examples/filters/filter_a_signal.rb

@@ -0,0 +1,38 @@
+plt = Digiproc::QuickPlot
+fns = Digiproc::Functions
+prob = Digiproc::Probability
+norm_dist = Digiproc::Probability::RealizedGaussianDistribution
+factory = Digiproc::Factories::FilterFactory
+
+# Make a signal with gaussian noise:
+# Create "white" Gaussian noise, 0 mean
+dist = norm_dist.new(mean: 0, stddev: 1, size: 16384)
+
+# Create a bandpass filter, make FT dimensions match
+bpfilter = factory.filter_for(type: "bandpass", wo: Math::PI / 2, bw: Math::PI / 5, transition_width: 0.0001, stopband_attenuation: 80)
+filter_dft = Digiproc::FFT.new(time_data: bpfilter.weights, size: 16384 * 4)
+
+# Get FT of White noise, calculate No 
+dist_fft = Digiproc::FFT.new(time_data: dist.data, size: 16384 * 4)
+n_o = 2 *  (dist_fft.magnitude.map{ |val| val ** 2}.sum.to_f / dist_fft.data.length)
+
+# Multiply freq domain of noise and filter to get output spectra
+# Calculate output energy
+filter_out = dist_fft * filter_dft
+total_noise_out = filter_out.magnitude.map{ |val| (val ** 2) * (1.0/ (4 * 16384)) }.sum 
+time_data_out = fns.ifft(filter_out.data).map(&:real)
+bw = 1.0 / 10
+
+puts "Normal Dist. Input \n\tMean:#{prob.mean(dist.data)}, Stddev: #{prob.stddev(dist.data)}"
+puts "No = #{n_o}"
+puts "Total Noise Energy Out: #{total_noise_out}"
+puts "Output: \n\tMean: #{prob.mean(time_data_out)}, Stddev: #{prob.stddev(time_data_out)}"
+puts "Calculated Noise Energy Out: #{ n_o * bw}"
+
+f =  fns.linspace(0,1,16384)
+
+path = './examples/filters/'
+plt.plot(x: f, y: filter_dft.dB, title: "Bandpass Filter", path: path)
+plt.plot(x: f, y: dist_fft.magnitude, title: "White Noise Spectra", path: path)
+plt.plot(x: f, y: filter_out.magnitude, title: "White Noise Mag Out of BP Filter", y_label: "Magnitude", path: path)
+plt.plot(x: f, y: filter_out.dB, title: "White Noise dB Out of BP Filter", y_label: "dB", path: path)

data/examples/functions/compute_probability.rb

@@ -0,0 +1,29 @@
+# Use Digiproc::Probability to calculate a QAM equation and find SNR
+
+
+qam_eqn = Proc.new do |db|
+    peb_no = 10 ** (db / 10.0)
+    pes_no = peb_no * Math.log(256,2)
+    pq = Digiproc::Probability.normal_q( Math.sqrt(pes_no * 3.0 / 255))
+    psmo2 = (Math.sqrt(256) - 2)
+    ppc1 = (1 - 2 * pq) ** 2
+    ppc2 = (1 - 2 * pq) * (1 - pq)
+    ppc3 = (1 - pq) ** 2
+    ps = 1 - (1.0 / 256) * ((psmo2 ** 2) * ppc1 + 4 * psmo2 * ppc2 + 4 * ppc3)
+    ps / Math.log(256, 2)
+end
+
+def findval(eqn, value, desired_val, step = 0.001 , tolerance = 0.000000005)
+    output = eqn[value]
+    if (output >= (desired_val - tolerance)) and (output <= (desired_val + tolerance))
+        return value
+    else
+        slope = (output <=> eqn[value + tolerance])
+        dir_to_output = output <=> desired_val
+        next_val = value + slope * dir_to_output * step
+        return findval(eqn, next_val, desired_val)
+    end
+end
+
+qam = findval(qam_eqn, 25 , 0.000001)
+puts "QAM Eb/No = #{qam}"

data/examples/functions/gram_schmidt.rb

@@ -0,0 +1,10 @@
+#GramSchmidtOrgonormalize calculates orthogonal vectors if possible
+# translate_center_to_origin centeres points around the origin
+
+messages = [[1,1], [1,-1], [-1,1]]
+output_vectors = Digiproc::Strategies::GramSchmidtOrthonormalize.new(messages).output
+puts output_vectors.to_s
+# Therefore, this signal cannot be reprisented in 3-D Space
+
+#Minimize energy in the 2-D reprisentation
+puts Digiproc::Functions.translate_center_to_origin([[1,1],[1,-1],[-1,1]]).to_s