spcore 0.2.0 → 0.2.1

data/lib/spcore/analysis/{correlation.rb → statistics.rb}

@@ -1,18 +1,38 @@
 module SPCore
-# Determines the normalized cross-correlation of a feature with an image.
-# Normalization is from -1 to +1, where +1 is high correlation, -1 is high
-# correlation (of inverse), and 0 is no correlation.
-#
-# For autocorrelation, just cross-correlate a signal with itself.
-#
-# @author James Tunnell
-class Correlation
-  attr_reader :data
-
+# Statistical analysis methods.
+class Statistics
+  # Compute the mean of a value series.
+  def self.sum values
+    return values.inject(0){ |s, x| s + x }
+  end
+  
+  # Compute the mean of a value series.
+  def self.mean values
+    return Statistics.sum(values) / values.size
+  end
+  
+  # Compute the standard deviation of a value series.
+  def self.std_dev values
+    size = values.size
+    raise ArgumentError, "size is <= 1" if size <= 1
+    
+    mean = Statistics.mean values
+    total_dist_from_mean = values.inject(0){|sum,x| sum + (x - mean)**2}
+    return Math.sqrt(total_dist_from_mean / (size - 1))
+  end
+  
+  # Determines the normalized cross-correlation of a feature with an image.
+  #
+  # Normalization is from -1 to +1, where +1 is high correlation, -1 is high
+  # correlation (of inverse), and 0 is no correlation.
+  #
+  # For autocorrelation, just cross-correlate a signal with itself.
+  #
   # @param [Array] image The values which are actually recieved/measured.
-  # @param [Array] feature The values to be searched for in the image. Size must not be greater than size of image.
+  # @param [Array] feature The values to be searched for in the image. Size must
+  #                not be greater than size of image.
   # @param [Fixnum] zero_padding Number of zeros to surround the image with.
-  def initialize image, feature, zero_padding = 0
+  def self.correlation image, feature, zero_padding = 0
     raise ArgumentError, "feature size is > image size" if feature.size > image.size
     
     unless zero_padding == 0
@@ -23,7 +43,7 @@ class Correlation
     feature_diff = feature.map {|x| x - feature_mean }
     sx = feature_diff.inject(0){ |s, x| s + x**2 }
     
-    @data = []
+    data = []
     for i in 0...(1 + image.size - feature.size)
       region = image[i...(i + feature.size)]
       region_mean = region.inject(0){|s,x| s + x } / feature.size.to_f
@@ -32,9 +52,9 @@ class Correlation
       
       if sx == 0 || sy == 0
         if sx == 0 && sy == 0
-          @data.push 1.0
+          data.push 1.0
         else
-          @data.push 0.0
+          data.push 0.0
         end
         
         next
@@ -48,8 +68,11 @@ class Correlation
       end
       
       r = sum / denom
-      @data.push(r)
-    end    
+      data.push(r)
+    end
+    
+    return data
   end
+
+end
 end
-end

data/lib/spcore/core/delay_line.rb

@@ -20,7 +20,7 @@ class DelayLine
   #                    :max_delay_seconds (reqd) and :delay_seconds (not reqd).
   #                    See ARG_SPECS for more details.
   def initialize args
-    hash_make DelayLine::ARG_SPECS, args
+    hash_make args, DelayLine::ARG_SPECS
     raise ArgumentError, "delay_seconds #{delay_seconds} is greater than max_delay_seconds #{max_delay_seconds}" if @delay_seconds > @max_delay_seconds
     @buffer = CircularBuffer.new((@sample_rate * @max_delay_seconds) + 1, :override_when_full => true)
     @buffer.push_ary Array.new(@buffer.size, 0.0)

data/lib/spcore/filters/fir/dual_sinc_filter.rb

@@ -24,7 +24,7 @@ class DualSincFilter
   # Given a filter order, 2 cutoff frequencies, sample rate, and window class,
   # develop a FIR filter kernel that can be used for lowpass filtering.
   def initialize args
-    hash_make DualSincFilter::ARG_SPECS, args
+    hash_make args, DualSincFilter::ARG_SPECS
     
     raise ArgumentError, "left_cutoff_freq is greater than 0.5 * sample_rate" if @left_cutoff_freq > (@sample_rate * 0.5)
     raise ArgumentError, "right_cutoff_freq is greater than 0.5 * sample_rate" if @right_cutoff_freq > (@sample_rate * 0.5)

data/lib/spcore/filters/fir/sinc_filter.rb

@@ -24,7 +24,7 @@ class SincFilter
   # Given a filter order, cutoff frequency, sample rate, and window class,
   # develop a FIR filter kernel that can be used for lowpass filtering.
   def initialize args
-    hash_make SincFilter::ARG_SPECS, args
+    hash_make args, SincFilter::ARG_SPECS
     
     raise ArgumentError, "cutoff_freq is greater than 0.5 * sample_rate" if @cutoff_freq > (@sample_rate / 2.0)
     

data/lib/spcore/generation/comb_filter.rb

@@ -0,0 +1,65 @@
+module SPCore
+class CombFilter
+  include Hashmake::HashMakeable
+  
+  FEED_FORWARD = :feedForward
+  FEED_BACK = :feedBack
+  
+  TYPES = [ FEED_FORWARD, FEED_BACK ]
+  
+  ARG_SPECS = {
+    :type => arg_spec(:reqd => true, :type => Symbol, :validator => ->(a){ TYPES.include?(a)}),
+    :frequency => arg_spec(:reqd => true, :type => Numeric, :validator => ->(a){ a > 0}),
+    :alpha => arg_spec(:reqd => true, :type => Float, :validator => ->(a){ a.between?(0.0,1.0) })
+  }
+  
+  attr_reader :type, :frequency, :alpha
+  
+  def initialize args
+    hash_make args, CombFilter::ARG_SPECS
+    calculate_params
+  end
+  
+  def type= type
+    ARG_SPECS[:type].validate_value type
+    @type = type
+  end
+
+  def frequency= frequency
+    ARG_SPECS[:frequency].validate_value frequency
+    @frequency = frequency
+    calculate_params
+  end
+  
+  def alpha= alpha
+    ARG_SPECS[:alpha].validate_value alpha
+    @alpha = alpha
+  end
+  
+  def frequency_response_at x
+    output = 0
+    if @type == FEED_FORWARD
+      output = Math.sqrt((1.0 + @alpha**2) + 2.0 * @alpha * Math.cos(@k * x))
+    elsif @type == FEED_BACK
+      output = 1.0 / Math.sqrt((1.0 + alpha**2) - 2.0 * @alpha * Math.cos(@k * x))
+    end
+    return output
+  end
+  
+  def frequency_response sample_rate, sample_count
+    output = []
+    sample_period = 1.0 / sample_rate
+    sample_count.times do |n|
+      x = sample_period * n
+      output.push frequency_response_at(x)
+    end
+    return output
+  end
+  
+  private
+  
+  def calculate_params
+    @k = (Math::PI * 2) * @frequency
+  end
+end
+end

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

@@ -38,7 +38,7 @@ class Oscillator
   #                    :wave_type, :frequency, :amplitude, :phase_offset, and :dc_offset.
   #                    See ARG_SPECS for more details.  
   def initialize args
-    hash_make Oscillator::ARG_SPECS, args
+    hash_make args, Oscillator::ARG_SPECS
     
     @phase_angle_incr = (@frequency * TWO_PI) / @sample_rate
     @current_phase_angle = @phase_offset

data/lib/spcore/{util → generation}/signal_generator.rb

@@ -14,7 +14,7 @@ class SignalGenerator
   # A new instance of SignalGenerator.
   # @param [Hash] args Required keys are :sample_rate and :size.
   def initialize args
-    hash_make ARG_SPECS, args
+    hash_make args, ARG_SPECS
   end
   
   # Generate a Signal object with noise data.

data/lib/spcore/util/envelope_detector.rb

@@ -20,7 +20,7 @@ class EnvelopeDetector
   #                    :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
+    hash_make args, EnvelopeDetector::ARG_SPECS
 
     @g_attack = Math.exp(-1.0 / (sample_rate * attack_time))
     @g_release = Math.exp(-1.0 / (sample_rate * release_time))

data/lib/spcore/util/gain.rb

@@ -1,184 +1,26 @@
+
 module SPCore
 # Provide utility functions to convert between a linear and decibel (logarithm) unit.
 class Gain
-  
-  #MAX_DB = 72
-  #NUM_DB_HALF_STEPS=146
-  #DB_TO_SCALAR_TABLE = [
-  #  1.0,              # 0 dB
-  #  1.059253725,      # 0.5
-  #  1.122018454,      # 1
-  #  1.188502227,      # 1.5
-  #  1.258925412,      # 2
-  #  1.333521432,      # 2.5
-  #  1.412537545,      # 3
-  #  1.496235656,      # 3.5
-  #  1.584893192,      # 4
-  #  1.678804018,      # 4.5
-  #  1.77827941,       # 5
-  #  1.883649089,      # 5.5
-  #  1.995262315,      # 6
-  #  2.11348904,       # 6.5
-  #  2.238721139,      # 7
-  #  2.371373706,      # 7.5
-  #  2.511886432,      # 8
-  #  2.66072506,       # 8.5
-  #  2.818382931,      # 9
-  #  2.985382619,      # 9.5
-  #  3.16227766,       # 10 dB
-  #  3.349654392,      # 10.5
-  #  3.548133892,      # 11
-  #  3.758374043,      # 11.5
-  #  3.981071706,      # 12
-  #  4.216965034,      # 12.5
-  #  4.466835922,      # 13
-  #  4.73151259,       # /13.5
-  #  5.011872336,      # 14
-  #  5.308844442,      # 14.5
-  #  5.623413252,      # 15
-  #  5.956621435,      # 15.5
-  #  6.309573445,      # 16
-  #  6.683439176,      # 16.5
-  #  7.079457844,      # 17
-  #  7.498942093,      # 17.5
-  #  7.943282347,      # 18
-  #  8.413951416,      # 18.5
-  #  8.912509381,      # 19
-  #  9.440608763,      # 19.5
-  #  10.0,             # 20 dB
-  #  10.59253725,      # 20.5
-  #  11.22018454,      # 21
-  #  11.88502227,      # 21.5
-  #  12.58925412,      # 22
-  #  13.33521432,      # 22.5
-  #  14.12537545,      # 23
-  #  14.96235656,      # 23.5
-  #  15.84893192,      # 24
-  #  16.78804018,      # 24.5
-  #  17.7827941,       # 25
-  #  18.83649089,      # 25.5
-  #  19.95262315,      # 26
-  #  21.1348904,       # 26.5
-  #  22.38721139,      # 27
-  #  23.71373706,      # 27.5
-  #  25.11886432,      # 28
-  #  26.6072506,       # 28.5
-  #  28.18382931,      # 29
-  #  29.85382619,      # 29.5
-  #  31.6227766,       # 30 dB
-  #  33.49654392,      # 30.5
-  #  35.48133892,      # 31
-  #  37.58374043,      # 31.5
-  #  39.81071706,      # 32
-  #  42.16965034,      # 32.5
-  #  44.66835922,      # 33
-  #  47.3151259,       # 33.5
-  #  50.11872336,      # 34
-  #  53.08844442,      # 34.5
-  #  56.23413252,      # 35
-  #  59.56621435,      # 35.5
-  #  63.09573445,      # 36
-  #  66.83439176,      # 36.5
-  #  70.79457844,      # 37
-  #  74.98942093,      # 37.5
-  #  79.43282347,      # 38
-  #  84.13951416,      # 38.5
-  #  89.12509381,      # 39
-  #  94.40608763,      # 39.5
-  #  100.0,            # 40 dB
-  #  105.9253725,      # 40.5
-  #  112.2018454,      # 41
-  #  118.8502227,      # 41.5
-  #  125.8925412,      # 42
-  #  133.3521432,      # 42.5
-  #  141.2537545,      # 43
-  #  149.6235656,      # 43.5
-  #  158.4893192,      # 44
-  #  167.8804018,      # 44.5
-  #  177.827941,       # 45
-  #  188.3649089,      # 45.5
-  #  199.5262315,      # 46
-  #  211.348904,       # 46.5
-  #  223.8721139,      # 47
-  #  237.1373706,      # 47.5
-  #  251.1886432,      # 48
-  #  266.072506,       # 48.5
-  #  281.8382931,      # 49
-  #  298.5382619,      # 49.5
-  #  316.227766,       # 50 dB
-  #  334.9654392,      # 50.5
-  #  354.8133892,      # 51
-  #  375.8374043,      # 51.5
-  #  398.1071706,      # 52
-  #  421.6965034,      # 52.5
-  #  446.6835922,      # 53
-  #  473.151259,       # 53.5
-  #  501.1872336,      # 54
-  #  530.8844442,      # 54.5
-  #  562.3413252,      # 55
-  #  595.6621435,      # 55.5
-  #  630.9573445,      # 56
-  #  668.3439176,      # 56.5
-  #  707.9457844,      # 57
-  #  749.8942093,      # 57.5
-  #  794.3282347,      # 58
-  #  841.3951416,      # 58.5
-  #  891.2509381,      # 59
-  #  944.0608763,      # 59.5
-  #  1000.0,           # 60 dB
-  #  1059.253725,      # 60.5
-  #  1122.018454,      # 61
-  #  1188.502227,      # 61.5
-  #  1258.925412,      # 62
-  #  1333.521432,      # 62.5
-  #  1412.537545,      # 63
-  #  1496.235656,      # 63.5
-  #  1584.893192,      # 64
-  #  1678.804018,      # 64.5
-  #  1778.27941,       # 65
-  #  1883.649089,      # 65.5
-  #  1995.262315,      # 66
-  #  2113.48904,       # 66.5
-  #  2238.721139,      # 67
-  #  2371.373706,      # 67.5
-  #  2511.886432,      # 68
-  #  2660.72506,       # 68.5
-  #  2818.382931,      # 69
-  #  2985.382619,      # 69.5
-  #  3162.27766,       # 70 dB
-  #  3349.654392,      # 70.5
-  #  3548.133892,      # 71
-  #  3758.374043,      # 71.5
-  #  3981.071706,      # 72
-  #]
-  #
-  #def self.db_to_linear db
-  #  raise ArgumentError, "#{db} db is not between -#{MAX_DB} and #{MAX_DB}" unless db.between(-MAX_DB, MAX_DB)
-  #  db_half_step = (dB * 2.0).to_i
-  #
-  #  if(db_half_step >= 0)
-  #    linear = DB_TO_SCALAR_TABLE[db_half_step]
-  #  elsif
-  #    linear = DB_TO_SCALAR_TABLE[-db_half_step]
-  #    scalar = 1.0 / scalar
-  #  end
-  #
-  #  return scalar
-  #end
 
   MAX_DB_ABS = 6000.0
 
   # Convert a decibel value to a linear value.
   def self.db_to_linear db
     db_abs = db.abs
-    raise ArgumentError, "|db| is #{db_abs}, which is greater than the allowed #{MAX_DB_ABS}" if db_abs > MAX_DB_ABS
+    raise ArgumentError, "decibel value #{db} is more than allowed maximum #{MAX_DB_ABS}" if db_abs > MAX_DB_ABS
+    raise ArgumentError, "decibel value #{db} is less than allowed minimum #{-MAX_DB_ABS}" if db_abs < -MAX_DB_ABS
     return 10.0**(db / 20.0)
   end
   
   # Convert a linear value to a decibel value.
   def self.linear_to_db linear
-    raise ArgumentError, "linear value #{linear} is less than or equal to 0.0" if linear <= 0.0
-    return 20.0 * Math::log10(linear)
+    raise ArgumentError, "linear value #{linear} is less than 0.0" if linear < 0.0
+    if linear == 0.0
+      return -MAX_DB_ABS
+    else
+      return 20.0 * Math::log10(linear)
+    end
   end
 
 end

data/lib/spcore/util/plotter.rb

@@ -21,7 +21,7 @@ class Plotter
   #                           All params are optional. See ARG_SPECS for
   #                           parameter details.
   def initialize hashed_args = {}
-    hash_make Plotter::ARG_SPECS, hashed_args
+    hash_make hashed_args, Plotter::ARG_SPECS
   end
   
   # Plot XY datapoints.

data/lib/spcore/{analysis → util}/signal.rb

@@ -9,7 +9,8 @@ class Signal
   # Used to process hashed arguments in #initialize.
   ARG_SPECS = {
     :data => arg_spec(:reqd => true, :type => Array, :validator => ->(a){ a.any? }),
-    :sample_rate => arg_spec(:reqd => true, :type => Fixnum, :validator => ->(a){ a > 0.0 })
+    :sample_rate => arg_spec(:reqd => true, :type => Numeric, :validator => ->(a){ a > 0.0 }),
+    #:fft_format => arg_spec(:reqd => false, :type => Symbol, :default => FFT_MAGNITUDE_DECIBEL, :validator => ->(a){FFT_FORMATS.include?(a)})
   }
   
   attr_reader :data, :sample_rate
@@ -19,18 +20,22 @@ class Signal
   # @param [Hash] hashed_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
+    hash_make hashed_args, Signal::ARG_SPECS
   end
   
   # Produce a new Signal object with the same data.
   def clone
-    Signal.new(:data => @data.clone, :sample_rate => @sample_rate)
+    new = Signal.new(:data => @data.clone, :sample_rate => @sample_rate)
+    new.instance_variable_set(:@frequency_domain, @frequency_domain)
+    return new
   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)
+    new = Signal.new(:data => @data[range], :sample_rate => @sample_rate)
+    new.instance_variable_set(:@frequency_domain, @frequency_domain)
+    return new
   end
   
   # Size of the signal data.
@@ -232,29 +237,56 @@ class Signal
     return self.clone.resample_hybrid!(upsample_factor, downsample_factor, filter_order)
   end
   
+  def frequency_domain fft_format = FrequencyDomain::FFT_MAGNITUDE_DECIBEL
+    if @frequency_domain.nil?
+      @frequency_domain = FrequencyDomain.new(
+        :time_data => @data,
+        :sample_rate => @sample_rate,
+        :fft_format => fft_format
+      )
+    end
+    return @frequency_domain
+  end
+  
+  # Return the full output of forward FFT on the signal data.
+  def fft_full
+    frequency_domain.fft_full
+  end
+
+  # Return the first half of the the forward FFT on the signal data.
+  def fft_half
+    frequency_domain.fft_half
+  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
-    
+  def freq_magnitudes
     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]
+    
+    fft_half.each_index do |i|
+      freq = frequency_domain.idx_to_freq(i)
+      freq_magnitudes[freq] = fft_half[i]
     end
     
     return freq_magnitudes
   end
 
+  # Apply FrequencyDomain.peaks to the signal and return the result.
+  def freq_peaks
+    return frequency_domain.peaks
+  end
+  
+  # Apply FrequencyDomain.harmonic_series to the signal frequency peaks and
+  # return the result.
+  def harmonic_series opts = {}
+    return frequency_domain.harmonic_series(opts)
+  end
+  
+  # Return the lowest frequency of the signal harmonic series.
+  def fundamental opts
+    return harmonic_series(opts).min
+  end
+  
   # Calculate the energy in current signal data.
   def energy
     return @data.inject(0.0){|sum,x| sum + (x * x)}
@@ -266,15 +298,49 @@ class Signal
     Math.sqrt(energy / size)
   end
   
-  # Compute the mean of signal data.
+  # Apply Statistics.mean to the signal data.
   def mean
-    sum = @data.inject(0){ |s, x| s + x }
-    return sum.to_f / size
+    Statistics.mean @data
+  end
+    
+  # Apply Statistics.std_dev to the signal data.
+  def std_dev
+    Statistics.std_dev @data
   end
   
-  # Find extrema (maxima, minima) within signal data.
+  # Apply Statistics.correlation to the signal data (as the image).
+  def correlation feature, zero_padding = 0
+    Statistics.correlation @data, feature, zero_padding
+  end
+
+  # Apply Features.extrema to the signal data.
   def extrema
-    return Extrema.new(@data)
+    return Features.extrema(@data)
+  end
+  
+  # Apply Features.outer_extrema to the signal data.
+  def outer_extrema
+    return Features.outer_extrema(@data)
+  end
+  
+  # Apply Features.minima to the signal data.
+  def minima
+    return Features.minima(@data)
+  end
+
+  # Apply Features.negative_minima to the signal data.
+  def negative_minima
+    return Features.negative_minima(@data)
+  end
+  
+  # Apply Features.maxima to the signal data.
+  def maxima
+    return Features.maxima(@data)
+  end
+
+  # Apply Features.positive_maxima to the signal data.
+  def positive_maxima
+    return Features.positive_maxima(@data)
   end
   
   # Operate on the signal data (in place) with the absolute value function.
@@ -287,22 +353,30 @@ class Signal
   def abs
     self.clone.abs!
   end
-  
+
+  # reduce all samples to the given level  
   def normalize! level = 1.0
     self.divide!(@data.max / level)
   end
   
-  # reduce all samples to 
+  # reduce all samples to the given level
   def normalize level = 1.0
     self.clone.normalize! level
   end
   
-  # Determine the envelope of the current Signal and return either a Envelope
-  # or a new Signal object as a result.
-  # @param [True/False] make_signal If true, return envelope data in a new
-  #                     Otherwise, return an Envelope object.
-  def envelope
-    Signal.new(:sample_rate => @sample_rate, :data => Envelope.new(@data).data)
+  # Apply Features.envelope to the signal data, and return either a new Signal
+  # object or the raw envelope data.
+  # @param [True/False] as_signal If true, return envelope data in a new signal
+  #                               object. Otherwise, return raw envelope data.
+  #                               Set to true by default.
+  def envelope as_signal = true
+    env_data = Features.envelope @data
+    
+    if as_signal
+      return Signal.new(:sample_rate => @sample_rate, :data => env_data)
+    else
+      return env_data
+    end
   end
   
   # Add data in array or other signal to the beginning of current data.
@@ -467,104 +541,19 @@ class Signal
   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
-  
-  # Differentiates the signal data.
-  # @param [true/false] make_signal If true, return the result as a new
-  #                                 Signal object. Otherwise, return result
-  #                                 as an array.
+  # Applies Calculus.derivative on the signal data, and returns a new Signal
+  # object with the result.
   def derivative
-    raise "Signal does not have at least 2 samples" unless @data.size > 2
-    
-    derivative = Array.new(@data.size)
-    sample_period = 1.0 / @sample_rate
-    
-    for i in 1...@data.count
-      derivative[i] = (@data[i] - @data[i-1]) / sample_period
-    end
-    
-    derivative[0] = derivative[1]
-    
-    return Signal.new(:sample_rate => @sample_rate, :data => derivative)
+    return Signal.new(:sample_rate => @sample_rate, :data => Calculus.derivative(@data))
   end
 
+  # Applies Calculus.integral on the signal data, and returns a new Signal
+  # object with the result.
+  def integral
+    return Signal.new(:sample_rate => @sample_rate, :data => Calculus.integral(@data))
+  end
+  
   # Removes all but the given range of frequencies from the signal, using
   # frequency domain filtering. Modifes and returns the current object.
   def remove_frequencies! freq_range
@@ -657,4 +646,4 @@ class Signal
     return self
   end
 end
-end
+end