spcore 0.1.0

data/lib/spcore/lib/saturation.rb

@@ -0,0 +1,45 @@
+module SPCore
+class Saturation
+  # Sigmoid-based saturation when input is above threshold.
+  # From musicdsp.org, posted by Bram.
+  def self.sigmoid input, threshold
+    input_abs = input.abs
+    if input_abs < threshold
+      return input
+    else
+      #y = threshold + (1.0 - threshold) * mock_sigmoid((input_abs - threshold) / ((1.0 - threshold) * 1.5))
+      y = threshold + (1.0 - threshold) * Math::tanh((input_abs - threshold)/(1-threshold))
+      
+      if input > 0.0
+        return y
+      else
+        return -y
+      end
+    end
+  end
+  
+  def self.gompertz input, threshold
+    a = threshold
+    b = -4
+    c = -2
+    x = input.abs
+    y = 2 * a * Math::exp(b * Math::exp(c * x))
+    
+    if input > 0.0
+      return y
+    else
+      return -y
+    end
+  end
+  
+  private
+  
+  #def self.mock_sigmoid x
+  #  if(x.abs < 1.0)
+  #    return x * (1.5 - 0.5 * x * x)
+  #  else
+  #    return x > 0.0 ? 1.0 : -1.0
+  #  end
+  #end
+end
+end

data/lib/spcore/version.rb

@@ -0,0 +1,4 @@
+module SPCore
+  # spcore version
+  VERSION = "0.1.0"
+end

data/spcore.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/spcore/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "spcore"
+  gem.version       = SPCore::VERSION
+  gem.summary       = %q{Perform basic signal processing functions (delay line, filters, envelope detection, etc...).}
+  gem.description   = <<DESCRIPTION
+Contains core signal processing functions, including:
+  Delay line
+  Biquad filters
+  Envelope detector
+  Conversion from dB-linear and linear-dB
+  Linear interpolation
+  Oscillator with selectable wave type (sine, square, triangle, sawtooth)
+
+DESCRIPTION
+  gem.license       = "MIT"
+  gem.authors       = ["James Tunnell"]
+  gem.email         = "jamestunnell@lavabit.com"
+  gem.homepage      = "https://rubygems.org/gems/spcore"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'hashmake'
+
+  gem.add_development_dependency 'bundler', '~> 1.0'
+  gem.add_development_dependency 'rake', '~> 0.8'
+  gem.add_development_dependency 'rspec', '~> 2.4'
+  gem.add_development_dependency 'yard', '~> 0.8'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'gnuplot'
+end

data/spec/core/limiters_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPCore::Limiters do
+  describe '.make_no_limiter' do
+    it 'should make a lambda that does not limit values' do
+      limiter = SPCore::Limiters.make_no_limiter
+      limiter.call(Float::MAX).should eq(Float::MAX)
+      limiter.call(-Float::MAX).should eq(-Float::MAX)
+      limiter.call(Float::MIN).should eq(Float::MIN)
+    end
+  end
+  
+  describe '.make_lower_limiter' do
+    it 'should make a lambda that limits values to be above the limit value' do
+      limiter = SPCore::Limiters.make_lower_limiter 5.0
+      limiter.call(4.5).should eq(5.0)
+      limiter.call(5.5).should eq(5.5)
+    end
+  end
+
+  describe 'make_upper_limiter' do
+    it 'should make a lambda that limits values to be above the limit value' do
+      limiter = SPCore::Limiters.make_upper_limiter 5.0
+      limiter.call(5.5).should eq(5.0)
+      limiter.call(4.5).should eq(4.5)
+    end
+  end
+
+  describe '.make_range_limiter' do
+    it 'should make a lambda that limits values to be between the limit range' do
+      limiter = SPCore::Limiters.make_range_limiter(2.5..5.0)
+      limiter.call(1.5).should eq(2.5)
+      limiter.call(5.5).should eq(5.0)
+      limiter.call(3.0).should eq(3.0)
+    end
+  end
+
+end

data/spec/lib/circular_buffer_spec.rb

@@ -0,0 +1,177 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPCore::CircularBuffer do
+  context '.new' do
+    it 'should set buffer size but fill count should be zero' do
+      [0,20,100].each do |size|
+        buffer = SPCore::CircularBuffer.new size
+        buffer.empty?.should be_true
+        buffer.size.should eq(size)
+      end
+    end
+  end
+  
+  describe '#push' do
+    it 'should report full after buffer.size calls to #push' do
+      [0,20,100].each do |size|
+        buffer = SPCore::CircularBuffer.new size
+        
+        size.times do
+          buffer.push rand
+        end
+        
+        buffer.full?.should be_true
+      end
+    end
+  end
+
+  describe '#push_ary' do
+    it 'should add the given array' do
+      elements = [1,2,3,4,5,6]
+      buffer = SPCore::CircularBuffer.new elements.count
+      buffer.push_ary elements
+      buffer.to_ary.should eq(elements)
+    end
+  end
+  
+  describe '#pop' do
+    it 'should, with fifo set to true, after a series of pushes, report the first element pushed' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count, :fifo => true
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.pop.should eq(elements.first)
+    end
+
+    it 'should, with fifo set to false, after a series of pushes, report the last element pushed' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count, :fifo => false
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.pop.should eq(elements.last)
+    end
+  end
+  
+  describe '#newest' do
+    it 'should, after a series of pushes, report the last element pushed' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.newest.should eq(elements.last)
+    end
+    
+    it 'should, with fifo set to true, after a series of pushes and then a pop, report the last element pushed' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count, :fifo => true
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.pop
+      buffer.newest.should eq(elements.last)
+    end
+
+    it 'should, with fifo set to false, after a series of pushes and then a pop, report the second to last element pushed' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count, :fifo => false
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.pop
+      buffer.newest.should eq(elements[-2])
+    end
+    
+    it 'should, when given a relative index, report the element reverse-indexed from the newest' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count, :fifo => false
+      elements.each do |element|
+        buffer.push element
+      end
+      
+      for i in 0...elements.count do
+        buffer.newest(i).should eq(elements[elements.count - 1 - i])
+      end
+    end
+  end
+  
+  describe '#oldest' do
+    it 'should, after a series of pushes, report the first element pushed' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.oldest.should eq(elements.first)
+    end
+    
+    it 'should, with fifo set to true, after a series of pushes and then a pop, report the second element pushed' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count, :fifo => true
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.pop
+      buffer.oldest.should eq(elements[1])
+    end
+
+    it 'should, with fifo set to false, after a series of pushes and then a pop, report the first element pushed' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count, :fifo => false
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.pop
+      buffer.oldest.should eq(elements.first)
+    end
+    
+    it 'should, when given a relative index, report the element reverse-indexed from the newest' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count, :fifo => false
+      elements.each do |element|
+        buffer.push element
+      end
+      
+      for i in 0...elements.count do
+        buffer.oldest(i).should eq(elements[i])
+      end
+    end
+  end
+  
+  describe '#to_ary' do
+    it 'should produce an empty array for an empty buffer' do
+      buffer = SPCore::CircularBuffer.new 10
+      buffer.to_ary.should be_empty
+    end
+    
+    it 'should, after pushing an array of elements, produce an array of the same elements' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new elements.count, :fifo => true
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.to_ary.should eq(elements)
+    end
+
+    it 'should, after pushing and popping an array of elements several times and then pushing the array one last time, produce an array of the same elements' do
+      elements = [1,2,3,4,5]
+      buffer = SPCore::CircularBuffer.new(3 * elements.count, :fifo => true)
+      
+      5.times do
+        elements.each do |element|
+          buffer.push element
+        end
+        elements.count.times do
+          buffer.pop
+        end
+      end
+
+      elements.each do |element|
+        buffer.push element
+      end
+      buffer.to_ary.should eq(elements)
+    end
+  end
+end

data/spec/lib/cookbook_filter_spec.rb

@@ -0,0 +1,44 @@
+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 = 44000.0
+  #  crit_freq = 1000.0
+  #  max_test_freq = 10000.0
+  #  bw = 2
+  #  filter = SPCore::CookbookNotchFilter.new sample_rate
+  #  filter.set_critical_freq_and_bw crit_freq, bw
+  #  
+  #  freqs = []
+  #  dbs = []
+  #  
+  #  start_freq = 10.0
+  #  test_freq = start_freq
+  #  
+  #  200.times do
+  #    mag = filter.get_freq_magnitude_response test_freq
+  #
+  #    dbs << SPCore::Gain.linear_to_db(mag)
+  #    freqs << test_freq
+  #    
+  #    test_freq *= 1.035
+  #  end
+  #
+  #  Gnuplot.open do |gp|
+  #    Gnuplot::Plot.new(gp) do |plot|
+  #      plot.title  "Frequency Magnitude Response for Lowpass Filter with Critical Freq of #{crit_freq} and BW of #{bw}"
+  #      plot.xlabel "Frequency (f)"
+  #      plot.ylabel "Frequency Magnitude Response (dB) at f"
+  #      plot.logscale 'x'
+  #    
+  #      plot.data << Gnuplot::DataSet.new( [freqs, dbs] ) do |ds|
+  #        ds.with = "linespoints"
+  #        #ds.linewidth = 4
+  #      end
+  #    end
+  #  end
+  #  
+  #end
+end

data/spec/lib/delay_line_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPCore::DelayLine do
+  it 'should' do
+    SAMPLE_RATE = 44100.0
+    MAX_DELAY_SEC = 0.1
+    
+    5.times do
+      delay_line = SPCore::DelayLine.new(
+        :sample_rate => SAMPLE_RATE,
+        :max_delay_seconds => MAX_DELAY_SEC,
+        :delay_seconds => (rand * MAX_DELAY_SEC)
+      )
+      
+      rand_sample = rand
+      delay_line.push_sample rand_sample
+      delay_line.delay_samples.times do
+        delay_line.push_sample 0.0
+      end
+      
+      delay_line.delayed_sample.should eq(rand_sample)
+    end
+  end
+end

data/spec/lib/envelope_detector_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPCore::EnvelopeDetector do
+  describe '#process_sample' do
+    it 'should produce an output that follows the amplitude of the input' do
+      sample_rate = 10000.0
+      freqs = [20.0, 200.0, 2000.0]
+
+      envelope_start = 1.0
+      envelope_end = 0.0
+      
+      freqs.each do |freq|
+        osc = SPCore::Oscillator.new :sample_rate => sample_rate, :frequency => freq, :amplitude => envelope_start
+        detector = SPCore::EnvelopeDetector.new :sample_rate => sample_rate, :attack_time => (1e-2 / freq), :release_time => (1.0 / freq)
+        
+        # 1 full period to acclimate the detector to the starting envelope
+        (sample_rate / freq).to_i .times do
+          detector.process_sample osc.sample
+        end
+        
+        input = []
+        output = []
+        envelope = []
+        
+        # 5 full periods to track the envelope as it changes
+        sample_count = (5.0 * sample_rate / freq).to_i
+        sample_count.times do |n|
+          percent = n.to_f / sample_count
+          amplitude = SPCore::Interpolation.linear 0.0, envelope_start, 1.0, envelope_end, percent
+          osc.amplitude = amplitude
+          
+          sample = osc.sample
+          env = detector.process_sample sample        
+          
+          input << n
+          output << sample
+          envelope << env
+          
+          env.should be_within(0.25).of(amplitude)
+        end
+        
+        ## plot the data
+        # 
+        #Gnuplot.open do |gp|
+        #  Gnuplot::Plot.new( gp ) do |plot|
+        #  
+        #    plot.title  "Signal and Envelope"
+        #    plot.ylabel "sample n"
+        #    plot.xlabel "y[n]"
+        #    
+        #    plot.data = [
+        #      Gnuplot::DataSet.new( [input, output] ) { |ds|
+        #        ds.with = "lines"
+        #        ds.title = "Signal"
+        #        ds.linewidth = 2
+        #      },
+        #    
+        #      Gnuplot::DataSet.new( [ input, envelope ] ) { |ds|
+        #        ds.with = "lines"
+        #        ds.title = "Envelope"
+        #        ds.linewidth = 2
+        #      }
+        #    ]
+        #
+        #  end
+        #end
+
+      end
+    end
+  end
+end