spcore 0.1.2 → 0.1.3

data/spec/filters/iir/cookbook_filter_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'gnuplot'
+require 'pry'
+
+describe 'cookbook filter' do
+  it 'should produce a nice frequency response graph' do
+    #sample_rate = 4000.0
+    #crit_freq = 400.0
+    #min_test_freq = 10.0
+    #max_test_freq = (sample_rate / 2.0) - 1.0
+    #bw = 0.3
+    #
+    #[SPCore::CookbookLowpassFilter, SPCore::CookbookHighpassFilter, SPCore::CookbookBandpassFilter].each do |filter_class|
+    #  filter = filter_class.new sample_rate
+    #  filter.set_critical_freq_and_bw crit_freq, bw
+    #  
+    #  freq_response = {}
+    #  Scale.exponential(min_test_freq..max_test_freq, 200).each do |freq|
+    #    mag = filter.get_freq_magnitude_response freq
+    #    freq_response[freq] = SPCore::Gain.linear_to_db(mag)
+    #  end
+    #  
+    #  plotter = Plotter.new(
+    #    :title => "Frequency Magnitude Response for #{filter_class} with critical freq of #{crit_freq}",
+    #    :logscale => "x"
+    #  )
+    #  plotter.plot_2d "magnitude (dB)" => freq_response
+    #end
+  end
+end

data/spec/interpolation/interpolation_spec.rb

@@ -0,0 +1,49 @@
+require 'pry'
+require 'benchmark'
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPCore::Interpolation do
+  context '.linear' do
+    it 'should interpolate floating-point values' do
+      result = SPCore::Interpolation.linear 2.0, 4.0, 0.5
+      result.should eq(3.0)
+    end
+
+    it 'should interpolate integer values' do
+      result = SPCore::Interpolation.linear 20, 40, 0.5
+      result.should eq(30)
+    end
+  end
+
+  context '.cubic_hermite' do
+    it 'should look like...' do
+      y0, y1, y2, y3 = 1.75, 1, 0.75, -1.5
+
+      x_ary = []
+      y_ary = []
+
+      (0.0..1.0).step(0.05) do |x|
+        y = SPCore::Interpolation.cubic_hermite y0, y1, y2, y3, x
+        x_ary << x
+        y_ary << y
+      end
+
+      #Gnuplot.open do |gp|
+      #  Gnuplot::Plot.new(gp) do |plot|
+      #    plot.title  "interpolated values"
+      #    plot.xlabel "x"
+      #    plot.ylabel "f(x)"
+      #  
+      #    plot.data = [            
+      #      Gnuplot::DataSet.new( [ x_ary, y_ary ] ) { |ds|
+      #        ds.with = "linespoints"
+      #        ds.title = "cubic hermite"
+      #        ds.linewidth = 1
+      #      }
+      #    ]
+      #  end
+      #end
+    end
+  end
+
+end

data/spec/resampling/discrete_resampling_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'gnuplot'
+
+describe SPCore::DiscreteResampling do
+
+  context '.upsample' do
+    it 'should produce output signal with the same max frequency (put through forward FFT)' do
+      sample_rate = 400.0
+      test_freq = 10.0
+      size = 64
+      upsample_factor = 4
+      order = (sample_rate / test_freq).to_i
+      
+      signal1 = SignalGenerator.new(:sample_rate => sample_rate, :size => size).make_signal [test_freq]
+      signal1 *= BlackmanWindow.new(size).data
+      signal2 = signal1.clone.upsample_discrete upsample_factor, order
+      
+      #plotter = Plotter.new(:title => "Discrete upsampling by #{upsample_factor}")
+      #plotter.plot_1d("original signal" => signal1.data, "upsampled signal" => signal2.data)
+
+      signal2.size.should eq(signal1.size * upsample_factor)
+      
+      max_freq1 = signal1.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      max_freq2 = signal2.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      
+      percent_error = (max_freq1 - max_freq2).abs / max_freq1
+      percent_error.should be_within(0.1).of(0.0)
+    end
+  end
+
+  context '.downsample' do
+    it 'should produce output signal with the same max frequency (put through forward FFT)' do
+      sample_rate = 400.0
+      test_freq = 10.0
+      size = 128
+      downsample_factor = 4
+      order = (sample_rate / test_freq).to_i
+      
+      signal1 = SignalGenerator.new(:sample_rate => sample_rate, :size => size).make_signal [test_freq]
+      signal1 *= BlackmanWindow.new(size).data
+      signal2 = signal1.clone.downsample_discrete downsample_factor, order
+      
+      #plotter = Plotter.new(:title => "Discrete downsampling by #{downsample_factor}")
+      #plotter.plot_1d("original signal" => signal1.data, "downsampled signal" => signal2.data)
+
+      signal2.size.should eq(signal1.size / downsample_factor)
+      
+      max_freq1 = signal1.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      max_freq2 = signal2.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      
+      percent_error = (max_freq1 - max_freq2).abs / max_freq1
+      percent_error.should be_within(0.1).of(0.0)
+    end
+  end
+
+  context '.resample' do
+    it 'should produce output signal with the same max frequency (put through forward FFT)' do
+      sample_rate = 400.0
+      test_freq = 10.0
+      size = 64
+      upsample_factor = 4
+      downsample_factor = 4
+      order = (sample_rate / test_freq).to_i
+      
+      signal1 = SignalGenerator.new(:sample_rate => sample_rate, :size => size).make_signal [test_freq]
+      signal1 *= BlackmanWindow.new(size).data
+      signal2 = signal1.clone.resample_discrete upsample_factor, downsample_factor, order
+      
+      #plotter = Plotter.new(:title => "Discrete resampling, up by #{upsampling_factor}, down by #{downsample_factor}")
+      #plotter.plot_1d("original signal" => signal1.data, "resampled signal" => signal2.data)
+
+      signal2.size.should eq(signal1.size * upsample_factor / downsample_factor)
+      
+      max_freq1 = signal1.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      max_freq2 = signal2.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      
+      percent_error = (max_freq1 - max_freq2).abs / max_freq1
+      percent_error.should be_within(0.1).of(0.0)
+    end
+  end  
+end

data/spec/resampling/hybrid_resampling_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'gnuplot'
+
+describe SPCore::HybridResampling do
+
+  context '.resample' do
+    it 'should produce output signal with the same max frequency (put through forward FFT)' do
+      sample_rate = 400.0
+      test_freq = 10.0
+      size = 64
+      upsample_factor = 4
+      downsample_factor = 4
+      order = (sample_rate / test_freq).to_i
+      
+      signal1 = SignalGenerator.new(:sample_rate => sample_rate, :size => size).make_signal [test_freq]
+      signal1 *= BlackmanWindow.new(size).data
+      signal2 = signal1.clone.resample_hybrid upsample_factor, downsample_factor, order
+      
+      #plotter = Plotter.new(:title => "Discrete resampling, up by #{upsampling_factor}, down by #{downsample_factor}")
+      #plotter.plot_1d("original signal" => signal1.data, "resampled signal" => signal2.data)
+
+      signal2.size.should eq(signal1.size * upsample_factor / downsample_factor)
+      
+      max_freq1 = signal1.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      max_freq2 = signal2.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      
+      percent_error = (max_freq1 - max_freq2).abs / max_freq1
+      percent_error.should be_within(0.1).of(0.0)
+    end
+  end  
+end

data/spec/resampling/polynomial_resampling_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'gnuplot'
+
+describe SPCore::PolynomialResampling do
+
+  context '.upsample' do
+    it 'should produce output signal with the same max frequency (put through forward DFT)' do
+      sample_rate = 400.0
+      test_freq = 10.0
+      size = (sample_rate * 5.0 / test_freq).to_i
+      upsample_factor = 2.5
+      
+      generator = SignalGenerator.new :sample_rate => sample_rate, :size => size
+      signal1 = generator.make_signal [test_freq]
+      signal2 = signal1.clone.upsample_polynomial upsample_factor
+       
+      #plotter = Plotter.new(:title => "Polynomial upsampling by #{upsample_factor}")
+      #plotter.plot_1d("original signal" => signal1.data, "upsampled signal" => signal2.data)
+      
+      signal2.size.should eq(signal1.size * upsample_factor)
+      
+      max_freq1 = signal1.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      max_freq2 = signal2.freq_magnitudes.max_by{|freq, mag| mag }[0]
+      
+      percent_error = (max_freq1 - max_freq2).abs / max_freq1
+      percent_error.should be_within(0.1).of(0.0)
+    end
+  end
+  
+end

data/spec/transforms/dft_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'pry'
+require 'gnuplot'
+
+describe SPCore::DFT do
+  context '.forward' do
+  
+    it 'should produce a freq magnitude response peak that is within 10 percent of the test freq' do
+      dft_size = 64
+      sample_rate = 400.0
+      
+      test_freqs = [
+        20.0,
+        40.0,
+      ]
+      
+      test_freqs.each do |freq|
+        signal = SignalGenerator.new(:sample_rate => sample_rate, :size => dft_size).make_signal([freq])
+        signal *= BlackmanHarrisWindow.new(dft_size).data
+        
+        output = DFT.forward signal.data
+        output = output[0...(output.size / 2)]  # skip second half
+        output = output.map { |x| x.magnitude } # map complex values to magnitude
+  
+        freq_magnitudes = {}
+        output.each_index do |i|
+          f = (sample_rate * i) / dft_size
+          freq_magnitudes[f] = output[i]
+        end
+        
+        max_freq = freq_magnitudes.max_by {|f,mag| mag}[0]
+        percent_err = (max_freq - freq).abs / freq
+        percent_err.should be_within(0.10).of(0.0)
+      end
+    end
+  end
+  
+  context '.inverse' do
+  
+    it 'should produce a near-identical signal to the original sent into the forward DFT (with energy that is within 10 percent error of original signal)' do
+      dft_size = 32
+      sample_rate = 400.0
+      
+      test_freqs = [
+        20.0,
+        40.0,
+      ]
+      
+      test_freqs.each do |freq|
+        input = SignalGenerator.new(:sample_rate => sample_rate, :size => dft_size).make_signal([freq])
+        input *= BlackmanHarrisWindow.new(dft_size).data
+        
+        output = DFT.forward input.data
+        input2 = DFT.inverse output
+        
+        energy1 = input.energy
+        energy2 = input2.inject(0.0){|sum,x| sum + (x * x)}
+  
+        percent_err = (energy2 - energy1).abs / energy1
+        percent_err.should be_within(0.10).of(0.0)
+        
+        #Plotter.new(
+        #  :title => "#{dft_size}-point DFT on #{freq} Hz sine wave signal",
+        #  :xlabel => "frequency (Hz)",
+        #  :ylabel => "magnitude response",
+        #).plot_1d("input1" => input.data, "input2" => input2)
+      end
+    end
+  end
+
+end

data/spec/transforms/fft_spec.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'pry'
+require 'gnuplot'
+
+describe SPCore::FFT do
+  context '.forward' do
+    it 'should produce a freq magnitude response peak that is within 10 percent of the test freq' do
+      fft_size = 64
+      sample_rate = 400.0
+      
+      test_freqs = [
+        20.0,
+        40.0,
+      ]
+      
+      test_freqs.each do |freq|
+        osc = Oscillator.new(:frequency => freq, :sample_rate => sample_rate)
+  
+        input_size = fft_size
+  
+        input = Array.new(input_size)
+        window = BlackmanHarrisWindow.new(input_size)
+        
+        input_size.times do |i|
+          input[i] = osc.sample * window.data[i]
+        end
+        
+        output = FFT.forward input
+        output = output[0...(output.size / 2)]
+        output = output.map { |x| x.magnitude } # map complex values to magnitude
+  
+        magn_response = {}
+        output.each_index do |n|
+          f = (sample_rate * n) / (output.size * 2)
+          magn_response[f] = output[n]
+        end
+        
+        max_freq = magn_response.max_by {|f,magn| magn }[0]
+        percent_err = (max_freq - freq).abs / freq
+        percent_err.should be_within(0.10).of(0.0)
+        
+        #Plotter.new(
+        #  :title => "#{input_size}-point FFT on #{freq} Hz sine wave signal",
+        #  :xlabel => "frequency (Hz)",
+        #  :ylabel => "magnitude response",
+        #).plot_2d("magnitude response" => magn_response)
+      end
+    end
+  end
+
+  context '.inverse' do
+
+    it 'should produce a near-identical signal to the original sent into the forward DFT (with energy that is within 10 percent error of original signal)' do
+      fft_size = 32
+      sample_rate = 400.0
+      
+      test_freqs = [
+        20.0,
+        40.0,
+      ]
+      
+      test_freqs.each do |freq|
+        input = SignalGenerator.new(:sample_rate => sample_rate, :size => fft_size).make_signal([freq])
+        input *= BlackmanHarrisWindow.new(fft_size).data
+        
+        output = FFT.forward input.data
+        input2 = FFT.inverse output
+        
+        energy1 = input.energy
+        energy2 = input2.inject(0.0){|sum,x| sum + (x * x)}
+  
+        percent_err = (energy2 - energy1).abs / energy1
+        percent_err.should be_within(0.10).of(0.0)
+
+        #Plotter.new(
+        #  :title => "#{fft_size}-point FFT on #{freq} Hz sine wave signal",
+        #  :xlabel => "frequency (Hz)",
+        #  :ylabel => "magnitude response",
+        #).plot_1d("input1" => input.data, "input2" => input2)
+      end
+    end
+  end
+  
+end

data/spec/{lib → util}/gain_spec.rb

@@ -19,7 +19,7 @@ describe SPCore::Gain do
 
     it 'should prove to be the inverse of .db_to_linear' do
       20.times do
-        x = SPCore::Interpolation.linear(0.0, -SPCore::Gain::MAX_DB_ABS, 1.0, SPCore::Gain::MAX_DB_ABS, rand)
+        x = SPCore::Interpolation.linear(-SPCore::Gain::MAX_DB_ABS, SPCore::Gain::MAX_DB_ABS, rand)
         y = SPCore::Gain::db_to_linear(x)
         z = SPCore::Gain::linear_to_db(y)
         ((z - x).abs / x).should be_within(1e-5).of(0.0)
@@ -38,7 +38,7 @@ describe SPCore::Gain do
       20.times do
         max_gain_linear = SPCore::Gain::db_to_linear(SPCore::Gain::MAX_DB_ABS)
         min_gain_linear = SPCore::Gain::db_to_linear(-SPCore::Gain::MAX_DB_ABS)
-        x = SPCore::Interpolation.linear(0.0, min_gain_linear, 1.0, max_gain_linear, rand)
+        x = SPCore::Interpolation.linear(min_gain_linear, max_gain_linear, rand)
         y = SPCore::Gain::linear_to_db(x)
         z = SPCore::Gain::db_to_linear(y)
         ((z - x).abs / x).should be_within(1e-5).of(0.0)

data/spec/util/signal_generator_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPCore::SignalGenerator do
+  before :all do
+    @sample_rate = 600.0
+    @test_freqs = [
+      65.0, 100.0, 250.0
+    ]
+  end
+  
+  context '.make_signal' do
+    context 'one freq at a time' do
+      it 'should produce the same output as a plain Oscillator' do
+        size = 60
+        generator = SignalGenerator.new :sample_rate => @sample_rate, :size => size
+        
+        @test_freqs.each do |freq|
+          signal = generator.make_signal [freq]
+          
+          osc = Oscillator.new(:sample_rate => @sample_rate, :frequency => freq)
+          osc_output = Array.new(size)
+          size.times do |i|
+            osc_output[i] = osc.sample
+          end
+          
+          signal.data.should eq(osc_output)
+        end
+      end
+    end
+
+    context 'many freqs at a time' do
+      it 'should produce the same output as equivalent plain Oscillators' do
+        size = 60
+        generator = SignalGenerator.new :sample_rate => @sample_rate, :size => size
+        
+        oscs = []
+        @test_freqs.each do |freq|
+          oscs.push Oscillator.new(:sample_rate => @sample_rate, :frequency => freq)
+        end
+        
+        signal = generator.make_signal @test_freqs
+
+        osc_output = Array.new(size, 0.0)
+        size.times do |i|
+          oscs.each do |osc|
+            osc_output[i] += osc.sample
+          end
+        end
+          
+        signal.data.should eq(osc_output)
+      end
+    end
+  end
+end