spcore 0.1.2 → 0.1.3

data/ChangeLog.rdoc

@@ -10,4 +10,17 @@
 
 === 0.1.1 / 2013-02-04
 
-Add EnvelopeDetector#attack_time= and EnvelopeDetector#release_time=
+Add EnvelopeDetector#attack_time= and EnvelopeDetector#release_time=
+
+=== 0.1.3 / 2013-02-18
+
+* Added:
+** A .cubic_hermite method to Interpolation class (implements cubic hermite polynomial interpolation)
+** Window classes (Blackman, Hann, Hamming, etc.)
+** DFT class, with .forward and .inverse methods.
+** FFT class, with .forward and .inverse methods.
+** Windowed sinc filter, a FIR filter for lowpass and highpass-
+** Dual windowed sinc filter, a FIR filter for bandpass and bandstop.
+** Discrete and Polynomial resampling classes, each with an .upsample method.
+** Plotter class to make graphing with gnuplot easier. Has #plot_1d and #plot_2d methods.
+** Signal class for testing convenience. Contains signal data and has convenience methods for plotting, correlation, energy, etc.

data/README.rdoc

@@ -6,16 +6,24 @@
 
 == Description
 
-Contains core signal processing functions. 
+A library of signal processing methods and classes.
 
 == Features
 
+Resampling (discrete up, down and up/down, polynomial up, and hybrid up/down)
+FFT transform (forward and inverse)
+DFT transform (forward and inverse)
+Windows (Blackman, Hamming, etc.)
+Windowed sinc filter for lowpass and highpass.
+Dual windowed sinc filter for bandpass and bandstop.
+Interpolation (linear and polynomial)
+Data plotting via gnuplot (must be installed to use).
 Delay line
 Biquad filters
 Envelope detector
 Conversion from dB-linear and linear-dB
-Linear interpolation
 Oscillator with selectable wave type (sine, square, triangle, sawtooth)
+Signal abstraction class.
 
 == Examples
 

data/lib/spcore.rb

@@ -1,19 +1,50 @@
 require 'hashmake'
 require 'spcore/version'
 
-require 'spcore/core/limiters'
+require 'spcore/core/circular_buffer'
 require 'spcore/core/constants'
+require 'spcore/core/delay_line'
+require 'spcore/core/envelope_detector'
+require 'spcore/core/oscillator'
+require 'spcore/core/signal'
 
-require 'spcore/lib/interpolation'
-require 'spcore/lib/circular_buffer'
-require 'spcore/lib/delay_line'
-require 'spcore/lib/gain'
-require 'spcore/lib/oscillator'
-require 'spcore/lib/biquad_filter'
-require 'spcore/lib/cookbook_allpass_filter'
-require 'spcore/lib/cookbook_bandpass_filter'
-require 'spcore/lib/cookbook_highpass_filter'
-require 'spcore/lib/cookbook_lowpass_filter'
-require 'spcore/lib/cookbook_notch_filter'
-require 'spcore/lib/envelope_detector'
-require 'spcore/lib/saturation'
+require 'spcore/windows/bartlett_hann_window'
+require 'spcore/windows/bartlett_window'
+require 'spcore/windows/blackman_harris_window'
+require 'spcore/windows/blackman_nuttall_window'
+require 'spcore/windows/blackman_window'
+require 'spcore/windows/cosine_window'
+require 'spcore/windows/flat_top_window'
+require 'spcore/windows/gaussian_window'
+require 'spcore/windows/hamming_window'
+require 'spcore/windows/hann_window'
+require 'spcore/windows/lanczos_window'
+require 'spcore/windows/nuttall_window'
+require 'spcore/windows/rectangular_window'
+require 'spcore/windows/triangular_window'
+
+require 'spcore/filters/fir/fir'
+require 'spcore/filters/fir/sinc_filter'
+require 'spcore/filters/fir/dual_sinc_filter'
+require 'spcore/filters/iir/biquad_filter'
+require 'spcore/filters/iir/cookbook_allpass_filter'
+require 'spcore/filters/iir/cookbook_bandpass_filter'
+require 'spcore/filters/iir/cookbook_highpass_filter'
+require 'spcore/filters/iir/cookbook_lowpass_filter'
+require 'spcore/filters/iir/cookbook_notch_filter'
+
+require 'spcore/interpolation/interpolation'
+
+require 'spcore/transforms/dft'
+require 'spcore/transforms/fft'
+
+require 'spcore/resampling/discrete_resampling'
+require 'spcore/resampling/polynomial_resampling'
+require 'spcore/resampling/hybrid_resampling'
+
+require 'spcore/util/gain'
+require 'spcore/util/limiters'
+require 'spcore/util/plotter'
+require 'spcore/util/saturation'
+require 'spcore/util/scale'
+require 'spcore/util/signal_generator'

data/lib/spcore/{lib → core}/circular_buffer.rb

@@ -1,9 +1,26 @@
 module SPCore
+# A circular (ring) buffer. The same array is used to store data over the life
+# of the buffer, unless the size is changed. As data is pushed and popped indices
+# are updated to track the oldest and newest elements.
+#
+# Push behavior can be modified by setting override_when_full. If true, when the
+# fill count reaches buffer size then new data will override the oldest data. If
+# false, when fill count is maxed the new data will raise an exception.
+#
+# Pop behavior can be modified by setting fifo to true or false. If true, pop will
+# return the oldest data (data first pushed). If false, pop will return the newest
+# data (data last pushed). 
+#
+# @author James Tunnell
 class CircularBuffer
   
   attr_accessor :fifo, :override_when_full
   attr_reader :fill_count
-  
+
+  # A new instance of CircularBuffer.
+  # @param [Fixnum] size The buffer size (and maximum fill count).
+  # @param [Hash] opts Contain optional arguments to modify buffer push/pop behavior.
+  #                    Valid keys are :override_when_full and :fifo.
   def initialize size, opts = {}
     
     opts = { :fifo => true, :override_when_full => true }.merge opts
@@ -17,18 +34,22 @@ class CircularBuffer
     @override_when_full = opts[:override_when_full]
   end
   
+  # Return the buffer size (max fill count).
   def size
     return @buffer.count
   end
   
+  # Return true if the buffer is empty.
   def empty?
     return @fill_count == 0
   end
   
+  # Return true if the buffer is full (fill count == buffer size).
   def full?
     return (@fill_count == size)
   end
 
+  # Change the buffer size, allocating a new backing array at the same time.
   def resize size
     rv = false
     if(size != @buffer.count)
@@ -41,6 +62,8 @@ class CircularBuffer
     return rv
   end
   
+  # Return an array containing the data layed out contiguously (data normally is
+  # split somewhere along the backing array).
   def to_ary
     if empty?
       return []
@@ -59,6 +82,7 @@ class CircularBuffer
     end
   end
   
+  # push a single data element.
   def push element
     if full?
       raise ArgumentError, "buffer is full, and override_when_full is false" unless @override_when_full
@@ -81,12 +105,14 @@ class CircularBuffer
     end
   end
 
+  # push an array of data elements.
   def push_ary ary
     ary.each do |element|
       push element
     end
   end
 
+  # access the latest data element.
   def newest relative_index = 0
     raise ArgumentError, "buffer is empty" if empty?
     raise ArgumentError, "relative_index is greater or equal to @fill_count" if relative_index >= @fill_count
@@ -105,6 +131,7 @@ class CircularBuffer
     return @buffer[absIdx];
   end
   
+  # access the oldest data element.
   def oldest relative_index = 0
     raise ArgumentError, "buffer is empty" if empty?
     raise ArgumentError, "relative_index is greater or equal to @fill_count" if relative_index >= @fill_count

data/lib/spcore/core/constants.rb

@@ -1,4 +1,10 @@
 module SPCore
+  # Two times PI
   TWO_PI = Math::PI * 2.0
-  NEG_PI = -Math::PI
+  # Four times PI
+  FOUR_PI = Math::PI * 4.0
+  # Six times PI
+  SIX_PI = Math::PI * 6.0
+  # Eight times PI
+  EIGHT_PI = Math::PI * 8.0
 end

data/lib/spcore/{lib → core}/delay_line.rb

@@ -1,15 +1,24 @@
 module SPCore
+# Delays samples for a period of time by pushing them through a circular buffer.
+#
+# @author James Tunnell
 class DelayLine
   include Hashmake::HashMakeable
   
   attr_reader :sample_rate, :max_delay_seconds, :delay_seconds, :delay_samples
-  
+
+  # Used to process hashed arguments in #initialize.
   ARG_SPECS = [
     Hashmake::ArgSpec.new(:reqd => true, :key => :sample_rate, :type => Float, :validator => ->(a){ a > 0.0 } ),
     Hashmake::ArgSpec.new(:reqd => true, :key => :max_delay_seconds, :type => Float, :validator => ->(a){ (a > 0.0) } ),
     Hashmake::ArgSpec.new(:reqd => false, :key => :delay_seconds, :type => Float, :default => 0.0, :validator => ->(a){ a >= 0.0 } ),
   ]
   
+  # A new instance of DelayLine. The circular buffer is filled by pushing an array
+  # of zeros.
+  # @param [Hash] args Hashed arguments. Valid keys are :sample_rate (reqd),
+  #                    :max_delay_seconds (reqd) and :delay_seconds (not reqd).
+  #                    See ARG_SPECS for more details.
   def initialize args
     hash_make DelayLine::ARG_SPECS, args
     raise ArgumentError, "delay_seconds #{delay_seconds} is greater than max_delay_seconds #{max_delay_seconds}" if @delay_seconds > @max_delay_seconds
@@ -18,20 +27,21 @@ class DelayLine
     self.delay_seconds=(@delay_seconds)
   end
   
+  # Set the delay in seconds. Actual delay will vary according because an
+  # integer number of delay samples is used.
   def delay_seconds= delay_seconds
     delay_samples_floor = (@sample_rate * delay_seconds).floor
     @delay_samples = delay_samples_floor.to_i
     @delay_seconds = delay_samples_floor / @sample_rate
-    
-    #if @buffer.fill_count < @delay_samples
-    #  @buffer.push_ary Array.new(@delay_samples - @buffer.fill_count, 0.0)
-    #end
   end
   
+  # Push a new sample through the circular buffer, overriding the oldest.
   def push_sample sample
     @buffer.push sample
   end
   
+  # Get the sample which is delayed by the number of samples that equates
+  # to the set delay in seconds.
   def delayed_sample
     return @buffer.newest(@delay_samples)
   end

data/lib/spcore/{lib → core}/envelope_detector.rb

@@ -1,7 +1,11 @@
 module SPCore
+# Tracks the envelope of samples as they are passed in one by one.
+#
+# @author James Tunnell
 class EnvelopeDetector
   include Hashmake::HashMakeable
   
+  # Used to process hashed arguments in #initialize.
   ARG_SPECS = [
     Hashmake::ArgSpec.new(:reqd => true, :key => :sample_rate, :type => Float, :validator => ->(a){ a > 0.0 } ),
     Hashmake::ArgSpec.new(:reqd => true, :key => :attack_time, :type => Float, :validator => ->(a){ a > 0.0 } ),
@@ -9,7 +13,12 @@ class EnvelopeDetector
   ]
 
   attr_reader :envelope, :sample_rate, :attack_time, :release_time
-  
+
+  # A new instance of EnvelopeDetector. The envelope is initialized to zero.
+  #
+  # @param [Hash] args Hashed arguments. Valid keys are :sample_rate (reqd),
+  #                    :attack_time (in seconds) (reqd) and :release_time
+  #                    (in seconds) (reqd). See ARG_SPECS for more details.  
   def initialize args
     hash_make EnvelopeDetector::ARG_SPECS, args
 
@@ -19,18 +28,21 @@ class EnvelopeDetector
     @envelope = 0.0
   end
   
+  # Set the attack time (in seconds).
   def attack_time= attack_time
     raise ArgumentError, "attack_time is <= 0.0" if attack_time <= 0.0
     @g_attack = Math.exp(-1.0 / (sample_rate * attack_time))
     @attack_time = attack_time
   end
 
+  # Set the release time (in seconds).
   def release_time= release_time
     raise ArgumentError, "release_time is <= 0.0" if release_time <= 0.0
     @g_release = Math.exp(-1.0 / (sample_rate * release_time))
     @release_time = release_time
   end
   
+  # Process a sample, returning the updated envelope.
   def process_sample sample
     input_abs = sample.abs
       

data/lib/spcore/{lib → core}/oscillator.rb

@@ -1,16 +1,26 @@
 module SPCore
+# A generic oscillator base class, which can render a sample for any phase 
+# between -PI and +PI.
+#
+# @author James Tunnell
 class Oscillator
   include Hashmake::HashMakeable
   attr_accessor :wave_type, :amplitude, :dc_offset
   attr_reader :frequency, :sample_rate, :phase_offset
   
+  # Defines a sine wave type.
   WAVE_SINE = :waveSine
+  # Defines a triangle wave type.
   WAVE_TRIANGLE = :waveTriangle
+  # Defines a sawtooth wave type.
   WAVE_SAWTOOTH = :waveSawtooth
+  # Defines a square wave type.
   WAVE_SQUARE = :waveSquare
 
+  # Defines a list of the valid wave types.
   WAVES = [WAVE_SINE, WAVE_TRIANGLE, WAVE_SAWTOOTH, WAVE_SQUARE]
   
+  # Used to process hashed arguments in #initialize.
   ARG_SPECS = [
     Hashmake::ArgSpec.new(:reqd => true, :key => :sample_rate, :type => Float, :validator => ->(a){ a > 0.0 } ),
     Hashmake::ArgSpec.new(:reqd => false, :key => :wave_type, :type => Symbol, :default => WAVE_SINE, :validator => ->(a){ WAVES.include? a } ),
@@ -19,7 +29,14 @@ class Oscillator
     Hashmake::ArgSpec.new(:reqd => false, :key => :phase_offset, :type => Float, :default => 0.0 ),
     Hashmake::ArgSpec.new(:reqd => false, :key => :dc_offset, :type => Float, :default => 0.0 ),
   ]
-
+  
+  # A new instance of Oscillator. The controllable wave parameters are frequency,
+  # amplitude, phase offset, and DC offset. The current phase angle is initialized
+  # to the given phase offset.
+  #
+  # @param [Hash] args Hashed arguments. Required key is :sample_rate. Optional keys are
+  #                    :wave_type, :frequency, :amplitude, :phase_offset, and :dc_offset.
+  #                    See ARG_SPECS for more details.  
   def initialize args
     hash_make Oscillator::ARG_SPECS, args
     
@@ -27,25 +44,33 @@ class Oscillator
     @current_phase_angle = @phase_offset
   end
   
+  # Set the sample rate (also updates the rate at which phase angle increments).
+  # @raise [ArgumentError] if sample rate is not positive.
   def sample_rate= sample_rate
+    raise ArgumentError, "sample_rate is not > 0" unless sample_rate > 0
     @sample_rate = sample_rate
     self.frequency = @frequency
   end
   
+  # Set the frequency (also updates the rate at which phase angle increments).
   def frequency= frequency
+    raise ArgumentError, "frequency is not > 0" unless frequency > 0
     @frequency = frequency
     @phase_angle_incr = (@frequency * TWO_PI) / @sample_rate
   end
   
+  # Set the phase angle offset. Update the current phase angle according to the
+  # difference between the current phase offset and the new phase offset.
   def phase_offset= phase_offset
     @current_phase_angle += (phase_offset - @phase_offset);
     @phase_offset = phase_offset
   end
 
+  # Step forward one sampling period and sample the oscillator waveform.
   def sample
     output = 0.0
 
-    while(@current_phase_angle < NEG_PI)
+    while(@current_phase_angle < -Math::PI)
       @current_phase_angle += TWO_PI
     end
 
@@ -69,10 +94,13 @@ class Oscillator
     @current_phase_angle += @phase_angle_incr
     return output
   end
-
+  
+  # constant used to calculate sine wave
   K_SINE_B = 4.0 / Math::PI
+  # constant used to calculate sine wave
   K_SINE_C = -4.0 / (Math::PI * Math::PI)
   # Q = 0.775
+  # constant used to calculate sine wave
   K_SINE_P = 0.225
   
   # generate a sine wave:
@@ -88,6 +116,7 @@ class Oscillator
     return y
   end
 
+  # constant used to calculate triangle wave
   K_TRIANGLE_A = 2.0 / Math::PI;
 
   # generate a triangle wave:
@@ -104,6 +133,7 @@ class Oscillator
     (x >= 0.0) ? 1.0 : -1.0
   end
 
+  # constant used to calculate sawtooth wave
   K_SAWTOOTH_A = 1.0 / Math::PI
 
   # generate a sawtooth wave:

data/lib/spcore/core/signal.rb

@@ -0,0 +1,350 @@
+module SPCore
+# Store signal data and provide some useful methods for working with
+# (testing and analyzing) the data.
+#
+# @author James Tunnell
+class Signal
+  include Hashmake::HashMakeable
+  
+  # Used to process hashed arguments in #initialize.
+  ARG_SPECS = [
+    Hashmake::ArgSpec.new(:key => :data, :reqd => true, :type => Array, :validator => ->(a){ a.any? }),
+    Hashmake::ArgSpec.new(:key => :sample_rate, :reqd => true, :type => Float, :validator => ->(a){ a > 0.0 })
+  ]
+  
+  attr_reader :data, :sample_rate
+
+  # A new instance of Signal.
+  #
+  # @param [Hash] args Hashed arguments. Required keys are :data and :sample_rate.
+  #                    See ARG_SPECS for more details.
+  def initialize hashed_args
+    hash_make Signal::ARG_SPECS, hashed_args
+  end
+  
+  # Produce a new Signal object with the same data.
+  def clone
+    Signal.new(:data => @data.clone, :sample_rate => @sample_rate)
+  end
+  
+  # Produce a new Signal object with a subset of the current signal data.
+  # @param [Range] range Used to pick the data range.
+  def subset range
+    Signal.new(:data => @data[range], :sample_rate => @sample_rate)
+  end
+  
+  # Size of the signal data.
+  def size
+    @data.size
+  end
+  
+  # Access signal data.
+  def [](arg)
+    @data[arg]
+  end
+  
+  def plot_data
+    plotter = Plotter.new(:title => "signal data sequence", :xtitle => "sample numbers", :ytitle => "sample values")
+    plotter.plot_1d "signal data" => @data
+  end
+  
+  # Increase the sample rate of signal data by the given factor using
+  # discrete upsampling method.
+  # @param [Fixnum] upsample_factor Increase the sample rate by this factor.
+  # @param [Fixnum] filter_order The filter order for the discrete lowpass filter.
+  def upsample_discrete upsample_factor, filter_order
+    @data = DiscreteResampling.upsample @data, @sample_rate, upsample_factor, filter_order
+    @sample_rate *= upsample_factor
+    return self
+  end
+
+  # Decrease the sample rate of signal data by the given factor using
+  # discrete downsampling method.
+  # @param [Fixnum] downsample_factor Decrease the sample rate by this factor.
+  # @param [Fixnum] filter_order The filter order for the discrete lowpass filter.
+  def downsample_discrete downsample_factor, filter_order
+    @data = DiscreteResampling.downsample @data, @sample_rate, downsample_factor, filter_order
+    @sample_rate /= downsample_factor
+    return self
+  end
+
+  # Change the sample rate of signal data by the given up/down factors, using
+  # discrete upsampling and downsampling methods.
+  # @param [Fixnum] upsample_factor Increase the sample rate by this factor.
+  # @param [Fixnum] downsample_factor Decrease the sample rate by this factor.
+  # @param [Fixnum] filter_order The filter order for the discrete lowpass filter.
+  def resample_discrete upsample_factor, downsample_factor, filter_order
+    @data = DiscreteResampling.resample @data, @sample_rate, upsample_factor, downsample_factor, filter_order
+    @sample_rate *= upsample_factor
+    @sample_rate /= downsample_factor
+    return self
+  end
+  
+  # Increase the sample rate of signal data by the given factor using
+  # polynomial interpolation.
+  # @param [Fixnum] upsample_factor Increase the sample rate by this factor.
+  def upsample_polynomial upsample_factor
+    @data = PolynomialResampling.upsample @data, @sample_rate, upsample_factor
+    @sample_rate *= upsample_factor
+    return self
+  end
+
+  # Change the sample rate of signal data by the given up/down factors, using
+  # polynomial upsampling and discrete downsampling.
+  # @param [Fixnum] upsample_factor Increase the sample rate by this factor.
+  # @param [Fixnum] downsample_factor Decrease the sample rate by this factor.
+  # @param [Fixnum] filter_order The filter order for the discrete lowpass filter.
+  def resample_hybrid upsample_factor, downsample_factor, filter_order
+    @data = HybridResampling.resample @data, @sample_rate, upsample_factor, downsample_factor, filter_order
+    @sample_rate *= upsample_factor
+    @sample_rate /= downsample_factor
+    return self
+  end
+  
+  # Run FFT on signal data to find magnitude of frequency components.
+  # @param convert_to_db If true, magnitudes are converted to dB values.
+  # @return [Hash] contains frequencies mapped to magnitudes.
+  def freq_magnitudes convert_to_db = false
+    fft_output = FFT.forward @data
+    
+    fft_output = fft_output[0...(fft_output.size / 2)]  # ignore second half
+    fft_output = fft_output.map {|x| x.magnitude }  # map complex value to magnitude
+    
+    if convert_to_db
+      fft_output = fft_output.map {|x| Gain.linear_to_db x}
+    end
+    
+    freq_magnitudes = {}
+    fft_output.each_index do |i|
+      size = fft_output.size * 2 # mul by 2 because the second half of original fft_output was removed
+      freq = (@sample_rate * i) / size
+      freq_magnitudes[freq] = fft_output[i]
+    end
+    
+    return freq_magnitudes
+  end
+
+  # Calculate the energy in current signal data.
+  def energy
+    return @data.inject(0.0){|sum,x| sum + (x * x)}
+  end
+  
+  # Return a 
+  def envelope attack_time, release_time
+    raise ArgumentError, "attack_time #{attack_time } is less than or equal to zero" if attack_time <= 0.0
+    raise ArgumentError, "release_time #{release_time} is less than or equal to zero" if release_time <= 0.0
+    
+    env_detector = EnvelopeDetector.new(:attack_time => attack_time, :release_time => release_time, :sample_rate => @sample_rate)
+    
+    envelope = Array.new(@data.count)
+    
+    for i in 0...@data.count do
+      envelope[i] = env_detector.process_sample @data[i]
+    end
+    
+    return envelope
+  end
+  
+  # Add data in array or other signal to the beginning of current data.
+  def prepend other
+    if other.is_a?(Array)
+      @data = other.concat @data
+    elsif other.is_a?(Signal)
+      @data = other.data.concat @data  
+    end
+    return self
+  end
+
+  # Add data in array or other signal to the end of current data.
+  def append other
+    if other.is_a?(Array)
+      @data = @data.concat other
+    elsif other.is_a?(Signal)
+      @data = @data.concat other.data
+    end
+    return self
+  end
+  
+  # Add value, values in array, or values in other signal to the current
+  # data values, and update the current data with the results.
+  # @param other Can be Numeric (add same value to all data values), Array, or Signal.
+  def +(other)
+    if other.is_a?(Numeric)
+      @data.each_index do |i|
+        @data[i] += other
+      end
+    elsif other.is_a?(Signal)
+      raise ArgumentError, "other.data.size #{other.size} is not equal to data.size #{@data.size}" if other.data.size != @data.size
+      @data.each_index do |i|
+        @data[i] += other.data[i]
+      end
+    elsif other.is_a?(Array)
+      raise ArgumentError, "other.size #{other.size} is not equal to data.size #{@data.size}" if other.size != @data.size
+      @data.each_index do |i|
+        @data[i] += other[i]
+      end
+    else
+      raise ArgumentError, "other is not a Numeric, Signal, or Array"
+    end
+    return self
+  end
+  
+  # Subtract value, values in array, or values in other signal from the current
+  # data values, and update the current data with the results.
+  # @param other Can be Numeric (subtract same value from all data values), Array, or Signal.
+  def -(other)
+    if other.is_a?(Numeric)
+      @data.each_index do |i|
+        @data[i] -= other
+      end
+    elsif other.is_a?(Signal)
+      raise ArgumentError, "other.data.size #{other.size} is not equal to data.size #{@data.size}" if other.data.size != @data.size
+      @data.each_index do |i|
+        @data[i] -= other.data[i]
+      end
+    elsif other.is_a?(Array)
+      raise ArgumentError, "other.size #{other.size} is not equal to data.size #{@data.size}" if other.size != @data.size
+      @data.each_index do |i|
+        @data[i] -= other[i]
+      end
+    else
+      raise ArgumentError, "other is not a Numeric, Signal, or Array"
+    end
+    return self
+  end
+
+  # Multiply value, values in array, or values in other signal with the current
+  # data values, and update the current data with the results.
+  # @param other Can be Numeric (multiply all data values by the same value),
+  #              Array, or Signal.  
+  def *(other)
+    if other.is_a?(Numeric)
+      @data.each_index do |i|
+        @data[i] *= other
+      end
+    elsif other.is_a?(Signal)
+      raise ArgumentError, "other.data.size #{other.size} is not equal to data.size #{@data.size}" if other.data.size != @data.size
+      @data.each_index do |i|
+        @data[i] *= other.data[i]
+      end
+    elsif other.is_a?(Array)
+      raise ArgumentError, "other.size #{other.size} is not equal to data.size #{@data.size}" if other.size != @data.size
+      @data.each_index do |i|
+        @data[i] *= other[i]
+      end
+    else
+      raise ArgumentError, "other is not a Numeric, Signal, or Array"
+    end
+    return self
+  end
+  
+  # Divide value, values in array, or values in other signal into the current
+  # data values, and update the current data with the results.
+  # @param other Can be Numeric (divide same all data values by the same value),
+  #              Array, or Signal.
+  def /(other)
+    if other.is_a?(Numeric)
+      @data.each_index do |i|
+        @data[i] /= other
+      end
+    elsif other.is_a?(Signal)
+      raise ArgumentError, "other.data.size #{other.size} is not equal to data.size #{@data.size}" if other.data.size != @data.size
+      @data.each_index do |i|
+        @data[i] /= other.data[i]
+      end
+    elsif other.is_a?(Array)
+      raise ArgumentError, "other.size #{other.size} is not equal to data.size #{@data.size}" if other.size != @data.size
+      @data.each_index do |i|
+        @data[i] /= other[i]
+      end
+    else
+      raise ArgumentError, "other is not a Numeric, Signal, or Array"
+    end
+    return self
+  end
+
+  alias_method :add, :+
+  alias_method :subtract, :-
+  alias_method :multiply, :*
+  alias_method :divide, :/
+  
+  # Determine how well the another signal (g) correlates to the current signal (f).
+  # Correlation is determined at every point in f. The signal g must not be
+  # longer than f. Correlation involves moving g along f and performing
+  # convolution. Starting a the beginning of f, it continues until the end
+  # of g hits the end of f. Doesn't actually convolve, though. Instead, it
+  # adds 
+  #
+  # @param [Array] other_signal The signal to look for in the current signal.
+  # @param [true/false] normalize Flag to indicate if normalization should be
+  #                               performed on input signals (performed on a copy
+  #                               of the original data).
+  # @raise [ArgumentError] if other_signal is not a Signal or Array.
+  # @raise [ArgumentError] if other_signal is longer than the current signal data.
+  def cross_correlation other_signal, normalize = true
+    if other_signal.is_a? Signal
+      other_data = other_signal.data
+    elsif other_signal.is_a? Array
+      other_data = other_signal
+    else
+      raise ArgumentError, "other_signal is not a Signal or Array"
+    end
+    
+    f = @data
+    g = other_data
+    
+    raise ArgumentError, "g.count #{g.count} is greater than f.count #{f.count}" if g.count > f.count
+    
+    g_size = g.count
+    f_size = f.count
+    f_g_diff = f_size - g_size
+    
+    cross_correlation = []
+
+    if normalize
+      max = (f.max_by {|x| x.abs }).abs.to_f
+      
+      f = f.clone
+      g = g.clone
+      f.each_index {|i| f[i] =  f[i] / max }
+      g.each_index {|i| g[i] =  g[i] / max }
+    end
+
+    #puts "f: #{f.inspect}"
+    #puts "g: #{g.inspect}"
+
+    for n in 0..f_g_diff do
+      f_window = (n...(n + g_size)).entries
+      g_window = (0...g_size).entries
+      
+      sample = 0.0
+      for i in 0...f_window.count do
+        i_f = f_window[i]
+        i_g = g_window[i]
+        
+        #if use_relative_error
+        target = g[i_g].to_f
+        actual = f[i_f]
+        
+        #if target == 0.0 && actual != 0.0 && normalize
+        #  puts "target is #{target} and actual is #{actual}"
+        #  error = 1.0
+        #else
+          error = (target - actual).abs# / target
+        #end
+        
+        sample += error
+        
+        #else
+        #  sample += (f[i_f] * g[i_g])
+        #end
+      end
+      
+      cross_correlation << (sample)# / g_size.to_f)
+    end
+    
+    return cross_correlation
+  end  
+end
+
+end