noyes 0.4.1 → 0.6.1

data/FAQ

@@ -0,0 +1,35 @@
+Q:
+  Does this contain a pure Ruby implementation?
+A:
+  Yes.
+
+Q:
+  Does this contain a pure Java implementation?
+A:
+  Yes.
+
+Q:
+  How do I use the Java implementation from JRuby?
+A: 
+  require 'noyes_java.jar'
+  include NoyesJava
+
+Q:
+  How do I use the pure ruby implementation?
+A:
+  require 'noyes'
+  include Noyes
+
+Q:
+  Is there are recognizer I can use with this front end?
+A:
+  Yes, the include command line programs nrec sends the data
+  to a recognizer running on somewhere on the cloud.  Currently it
+  recognizes the names of NFL teams.  You can get audio data from
+  http://github.com/talkhouse/audiodata/tree/master/nfl/
+
+Q:
+  What does nrec stand for?
+
+A:
+  Noyes Recognizer.

data/README

@@ -5,10 +5,30 @@ Pronunciation:  Typically pronounced the same as 'noise'.  But "NO!... YES!" is
 considered acceptable if you yell it loudly enough or at least with sufficient
 conviction to make people think you have truly changed your mind.
 
+Noyes is a general purpose signal processing tool that is flexible enough for
+many purposes.  However, it exists because there is a need for low-latency high
+quality speech recognition on portable wireless devices.  The most powerful
+speech recognizers are very large with huge models running on powerful cloud
+based systems.  But transmitting raw audio to these recognizers creates too
+much latency because raw audio uses too much bandwidth.  By sending compressed
+features instead of raw audio the bandwidth can be greatly reduced without
+compromising recognition accuracy.  In some cases the effect of inadequate
+bandwidth on latency can be reduced to zero.
+
+Because hand sets require different implementations the Noyes library is
+designed to quickly and efficiently work with and develop multiple underlying
+implementations.  All implementations are accessible via a high level dynamic
+language that includes a very expressive domain specific language for handling
+signal processing routines.  In addition, all implementations share unit tests
+written in a high level dynamic language.
+
 Noyes is implemented entirely in Ruby.  It's also implemented entirely in Java.
 The Java version has Ruby bindings too.  So you can have Java's speed from
-Ruby.  All versions share the same unit tests, which are written in Ruby.  The
-design goal is to have signal processing routines that are so simple and so
+Ruby.  If you need a pure Java version you can use the generated jar.  There is
+a lot of flexibility without a lot of overhead.  All versions share the same
+unit tests, which are written in Ruby.
+
+The design goal is to have signal processing routines that are so simple and so
 disentangled from the overall system that anyone could extract any of the
 routines and use them elsewhere with little trouble.  Benchmarks are included.
 
@@ -23,10 +43,129 @@ the gem.
 
 Requirements:
   Almost any version of ruby & rake.
-  Java, if you want to use the Java version.
+  Java, if you want to use the Java implementation instead of the default pure
+  ruby implementation.
 
-  Some of the utility scripts may use sox, but
+  Some of the utility scripts such as nrec and jrec may use sox, but
   none of the core routines use it.
 
-For usage information:
+Build instructions
   rake -T
+
+
+= USAGE
+
+All signal processing routines use a simple DSL style inteface.  Below are some
+examples.
+
+== Filter operator example.
+The '>>=' operator is called the filter operator.  It modifies that data on the
+left using the filter on the right.  This is similar to the way the += operator
+works for numbers. Note that the >>= actually looks like a filter making it easy
+to remember.  
+
+  require 'noyes'
+  data = (1..12).to_a  # An array of nonesense data.
+  segmenter = Segmenter.new 4, 2 # window size, window shift 
+  hamming_filter = HammingWindow.new 4 # window size
+  power_spec_filter = PowerSpectrumFilter.new 8 # number of ffts
+
+  data >>= segmenter
+  data >>= hamming_filter
+  data >>= power_spec_filter
+  data >>= dct_filter
+
+You can expand the >>= operator out, but I think the flow is worse and there is
+more repetition, particularly when you have a lot of filters in sequence.  This
+is perfectly valid syntax though. Also, this is very useful if you don't want
+to keep a reference to your original data.
+
+  require 'noyes'
+  pcm_data = (1..12).to_a
+  segmenter = Segmenter.new
+  hamming_filter = HammingWindow.new 4
+  segmented_data = segmenter << pcm_data, 4, 2
+  hamming_data = hamming_filter <<  segmented_data
+  power_spectrum data = power_spec_filter hamminging_data, 8
+  dct_data = dct_filter << power_spectrum_data
+
+== Advanced filter DSLs
+For most things, the filter operator is simple, easy to remember, and
+very concise.  But sometimes you want to build more elaborate combinations
+of filters and use them as if you had a single filter.  In this case
+making a new classes for every possible combination creates an explosion
+of new classes and a maintainence nightmare.  Instead, there is a simple
+graph notation you can use to combine filters.  In the following example
+we'll combine all the filters from a previous example and then use them
+as if they were a single filter.
+
+  serial_filter = segmenter & hamming_filter & power_spec_filter & dct_filter
+  data >>= serial_filter
+
+It's also possible to take parallel data streams and pipe them through
+parallel filters as if you had only one data stream and only one filter.
+
+  data = [stream_1,stream_2]
+  parallel_filter = filter_1 | filter_2
+  data >>= parallel_filter
+  
+It is not necessary for the data to be synchronous when using parallel filters.
+When using parallel filters the number of elements going through one filter
+does not have to equal the number of elements going through the second filter.
+
+You can see that you can make arbitrarily complicated graphs of filters by
+combined use of the '&' and '|' operators.  Almost identical notation is used
+to specify graphs for context free grammars.  Keep in mind that '&' take
+precedence over '|'.  In the example below stream 1 goes through filter 1 and
+filter 2 while stream 2 goes through filters 3, 4, and 5.
+
+  parallel_data = [stream_1,stream_2]
+  big_filter = filter_1 & filter_2 | filter_3 & filter_4 & filter_5
+  parallel_data >>= big_filter
+
+== Command Line Utilities
+
+The program nrec will process almost any format of audio file into speech
+features and send the data to a cloud hosted speech recognizer.  The resulting
+transcript will be sent back and printed out.  The nrec program uses whatever
+version of Ruby is on the path of your current environment.  It is compatible
+with both ruby 1.9, ruby 1.8x, and JRuby.  When run under JRuby it can
+optionally use a Java implementation, which is very fast.  See nrec --help for
+more information.
+
+== Assessing Performance for Wireless Devices
+
+It's important to note that the performance characteristics of live data and
+recorded data are different.   Any delay experience by a user starts from the
+time they stop speaking.  In contrast, any delay experienced when processing a
+file starts from the time a file starts processing.  For that reason file
+processing always seems slower.  Modern recognizers are easily capable of
+exceeding real time performance so that it not a factor.  The delay experienced
+by a user is typically due to the time required to transmit the audio to the
+recognizer and the time required to detect end of utterance, assuming end of
+utterance detection is used.  
+
+If end of utterance detection is used the recognizer must wait until it has
+sufficient evidence to be reasonably sure the user has stopped talking.  This
+could mean that a suitable period of silence has passed which means the user
+incurs a slight but unavoidable delay.  End of utterance detection also could
+mean the grammar or language model does not allow for any other reasonable
+possibility even if more data were available, which may mean no delay at all
+(or even a negative delay in some cases).
+
+If the bandwidth of the network is low enough, which is often the case for the
+data channel of portable wireless handsets, it will take time for raw
+uncompressed audio to traverse the network.   By computing features on the
+handset it is possible to have significant reduction in bandwidth requirements
+eliminating much of the latency.  These features in turn may then be compressed
+for further bandwidth reduction.  This method exceeds what is possible with
+alternative methods of audio compression.  Further, it eliminates many of the
+distortion components that may compromise recognition accuracy.
+
+If all you want is a rough feeling of how responsive speech recognition will be
+over your network try speaking an utterance at the same time you enter a
+command to have a prerecorded utterance recognized.  You'll probably be
+surprised by how quickly the network is able to respond.  You may find that the
+Java implementation feels like instant response even though it takes time for
+the JVM to launch.  Ruby 1.9 is actually surprisingly quick on a reasonably
+powerful laptop.

data/bin/nrec

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# vim: set filetype=ruby :
+ROOT = File.dirname(File.dirname(__FILE__))
+$: << "#{ROOT}/lib" << "#{ROOT}/ship"
+
+require 'optparse'
+options = {}
+OptionParser.new do |opt|
+  opt.banner = 'Usage: nrec [options] file1 file2 ...'
+  opt.on '-v', '--verbose', 'Output more information' do 
+    options[:verbose] = true
+  end
+  options[:implementation] = :ruby
+  opt.on '-j', '--java', 'Use java implementation' do
+    options[:implementation] = :java
+  end
+  opt.on( '-h', '--help', 'Display this screen' ) do
+    puts opt
+    exit
+  end
+end.parse!
+
+# Must set implementation specific library path before requiring libraries.
+case options[:implementation]
+when :java
+  if RUBY_PLATFORM != 'java'
+    puts "The Java implementation is not accessable from Ruby, only JRuby."
+    puts "You'll need to check your environment carefully.  If you've"
+    puts "installed this gem under both ruby and jruby and both are in"
+    puts "your current environment you may have created a conflict."
+    puts "you must make sure the jruby path preceeds the ruby path."
+    exit
+  end
+  puts "Using Java implementation" if options[:verbose]
+  require 'noyes_java'
+  include NoyesJava
+when :ruby
+  if options[:verbose]
+    if RUBY_PLATFORM == 'java'
+      puts "Using pure ruby implementation under JRuby #{RUBY_VERSION}."
+    else
+      puts "Using pure ruby implementation under Ruby #{RUBY_VERSION}."
+    end
+  end
+
+  require 'noyes'
+  include Noyes
+end
+require 'socket'
+
+def recognize file, node='174.129.244.159', port=2348
+  TCPSocket.open(node, port) do |client|
+    send_incremental_features file, client, client
+  end
+end
+
+ARGV.each do |file|
+  puts "recognizing file #{file}" if options[:verbose]
+  result = recognize file
+  puts "\n#{result}"
+end

data/lib/common/parallel_filter.rb

@@ -12,7 +12,7 @@ module NoyesFilterDSL
       offset = -1
       @filters.map {|f| f << data[offset+=1]}
     end
-    def + other
+    def & other
       raise "Parameter does not respond to <<." unless other.respond_to? :<<
       if other.kind_of?(ParallelFilter) && filters.size != other.filters.size
         raise "Parallel filters must have equal dimensions %d vs %d " %

data/lib/common/serial_filter.rb

@@ -8,7 +8,7 @@ module NoyesFilterDSL
       @filters.each {|f| data >>= f}
       data
     end
-    def + other
+    def & other
       raise "Parameter does not respond to <<." unless other.respond_to? :<<
       if other.kind_of? SerialFilter
         return SerialFilter.new(@filters.clone + other.filters.clone)

data/lib/common.rb

@@ -0,0 +1,5 @@
+require 'common/serial_filter'
+require 'common/parallel_filter'
+require 'common/noyes_dsl'
+require 'common/noyes_math'
+require 'common/send_incrementally'

data/lib/java_impl/dct.rb

@@ -0,0 +1,13 @@
+require 'java_impl/java_filter'
+
+module NoyesJava
+  class DCT
+    include JavaFilter
+    def initialize order, ncol
+      @filter = Java::talkhouse.DiscreteCosineTransform.new order, ncol
+    end
+    def melcos
+      @filter.melcos.map {|a|a.to_a}
+    end
+  end
+end

data/lib/java_impl/delta.rb

@@ -0,0 +1,14 @@
+require 'java_impl/java_filter'
+
+module NoyesJava
+  class DoubleDeltaFilter
+    include JavaFilter
+    def initialize
+      @filter = Java::talkhouse.DoubleDeltaFilter.new
+    end
+    def final_estimate
+      x = @filter.final_estimate
+      x.map{|a|a.to_a}
+    end
+  end
+end

data/lib/java_impl/discrete_fourier_transform.rb

@@ -0,0 +1,10 @@
+require 'complex'
+
+module NoyesJava
+  def dft data, size
+    data = data.to_java :double
+    x = Java::talkhouse::DiscreteFourierTransform.apply data, size
+    x[0].zip(x[1]).map {|r, i| Complex(r,i)}
+  end
+  module_function :dft
+end 

data/lib/java_impl/hamming_window.rb

@@ -0,0 +1,10 @@
+require 'java_impl/java_filter'
+
+module NoyesJava
+  class HammingWindow
+    include JavaFilter
+    def initialize window_size
+      @filter = Java::talkhouse.HammingWindow.new window_size
+    end
+  end
+end

data/lib/java_impl/java_filter.rb

@@ -0,0 +1,15 @@
+module NoyesJava
+  module JavaFilter
+    def << data
+      java_matrix = @filter.apply data.to_java Java::double[]
+      java_matrix.map {|java_array|java_array.to_a}
+    end
+    def self.ensure_jarray array
+      if array.respond_to? :each
+        array.to_java(Java::double[]).to_a
+      else
+	array
+      end
+    end
+  end
+end

data/lib/java_impl/live_cmn.rb

@@ -0,0 +1,10 @@
+require 'java_impl/java_filter'
+
+module NoyesJava
+  class LiveCMN
+    include JavaFilter
+    def initialize dimensions=13, mean=45.0, window_size=100, shift=160
+      @filter = Java::talkhouse.LiveCMN.new 13, 45.0, 100, 160
+    end
+  end
+end 

data/lib/java_impl/log_compress.rb

@@ -0,0 +1,10 @@
+require 'java_impl/java_filter'
+
+module NoyesJava
+  class LogCompressor
+    include JavaFilter
+    def initialize log_zero = -0.00001
+      @filter = Java::talkhouse.LogCompressor.new log_zero
+    end
+  end
+end

data/lib/java_impl/mel_filter.rb

@@ -0,0 +1,28 @@
+require 'java_impl/java_filter'
+
+module NoyesJava
+  class MelFilter
+    include JavaFilter
+    def initialize srate, nfft, nfilt, lowerf, upperf
+      @filter = Java::talkhouse.MelFilter.new srate, nfft, nfilt, lowerf, upperf
+    end
+    def self.make_bank_parameters srate, nfft, nfilt, lowerf, upperf
+      parameters = Java::talkhouse.MelFilter.make_bank_parameters srate, nfft,
+                                                        nfilt, lowerf, upperf
+      parameters.map {|array|array.to_a}
+    end
+    def self.make_filter left, center, right, init_freq, delta
+      filters = Java::talkhouse.MelFilter.make_filter left, center, right,
+                                                      init_freq, delta
+      filters = filters.to_a
+      indefilters = filters.shift
+      [indefilters, filters]
+    end
+    def self.to_mel f
+      x = Java::talkhouse.MelFilter.mel JavaFilter.ensure_jarray f
+    end
+    def self.to_linear mel
+      Java::talkhouse.MelFilter.melinv JavaFilter.ensure_jarray mel
+    end
+  end
+end

data/lib/java_impl/power_spec.rb

@@ -0,0 +1,10 @@
+require 'java_impl/java_filter'
+
+module NoyesJava
+  class PowerSpectrumFilter
+    include JavaFilter
+    def initialize nfft
+      @filter = Java::talkhouse.PowerSpec.new nfft
+    end
+  end
+end

data/lib/java_impl/preemphasis.rb

@@ -0,0 +1,11 @@
+module NoyesJava
+  class Preemphasizer
+    include Math
+    def initialize factor=0.97
+      @filter = Java::talkhouse.Preemphasizer.new factor
+    end
+    def << data
+      @filter.apply(data.to_java(:double)).to_a
+    end
+  end
+end 

data/lib/java_impl/segment.rb

@@ -0,0 +1,11 @@
+module NoyesJava
+  class Segmenter
+    def initialize win_size, win_shift
+      @filter = Java::talkhouse.Segmenter.new win_size, win_shift
+    end
+    def << data
+      java_matrix = @filter.apply data.to_java(:double)
+      java_matrix.map {|java_array|java_array.to_a} if java_matrix
+    end
+  end
+end

data/lib/noyes.rb

@@ -1,15 +1,12 @@
-require 'serial_filter'
-require 'parallel_filter'
-require 'noyes_dsl'
-require 'noyes_math'
-require 'live_cmn'
-require 'dct'
-require 'delta'
-require 'filter'
-require 'mel_filter'
-require 'hamming_window'
-require 'log_compress'
-require 'discrete_fourier_transform'
-require 'power_spec'
-require 'preemphasis'
-require 'segment'
+require 'common'
+require 'ruby_impl/dct'
+require 'ruby_impl/delta'
+require 'ruby_impl/filter'
+require 'ruby_impl/mel_filter'
+require 'ruby_impl/hamming_window'
+require 'ruby_impl/log_compress'
+require 'ruby_impl/live_cmn'
+require 'ruby_impl/discrete_fourier_transform'
+require 'ruby_impl/power_spec'
+require 'ruby_impl/preemphasis'
+require 'ruby_impl/segment'

data/lib/noyes_java.rb

@@ -0,0 +1,14 @@
+require 'common'
+require 'java'
+require 'java_impl/dct'
+require 'java_impl/delta'
+require 'java_impl/filter'
+require 'java_impl/mel_filter'
+require 'java_impl/hamming_window'
+require 'java_impl/live_cmn'
+require 'java_impl/log_compress'
+require 'java_impl/discrete_fourier_transform'
+require 'java_impl/power_spec'
+require 'java_impl/preemphasis'
+require 'java_impl/segment'
+require 'noyes.jar'

data/lib/ruby_impl/dct.rb

@@ -1,4 +1,4 @@
-require 'noyes_math'
+require 'common/noyes_math'
 
 module Noyes
   # Takes the discrete cosing transform.  Converts a n x m matrix to an n x order

data/lib/ruby_impl/discrete_fourier_transform.rb

@@ -4,31 +4,34 @@ module Noyes
   include Math
   # Takes the discrete Fourier transform.
   def dft data,size
-    vals = Array.new(size) {|i| i < data.size ? Complex(data[i],0) : Complex(0,0)}
-  	j=0
-  	size.times do |i|
-  		vals[j],vals[i] = vals[i],vals[j] if i<j
-  		m = size/2
-  		while j>=m && m>1
-  			j-=m 
+    vals = Array.new(size) do |i| 
+      i < data.size ? Complex(data[i],0) : Complex(0,0)
+    end
+    j=0
+    size.times do |i|
+      vals[j],vals[i] = vals[i],vals[j] if i<j
+      m = size/2
+      while j>=m && m>1
+        j-=m 
         m/=2
-  		end
-  		j+=m
-  	end
-  	k=1
-  	while k<size
-  		incr = 2*k
-  		mul = Complex.polar 1, Math::PI/k
-  		w = Complex(1, 0)
-  		k.times do |i|
-  			i.step(size-1,incr) do |j|
-  				tmp =  w * vals[j+k]
-  				vals[j+k],vals[j]=vals[j]-tmp,vals[j]+tmp
-  			end
-  			w *= mul;
-  		end
-  		k=incr
-  	end
-  	vals
+      end
+      j+=m
+    end
+    k=1
+    while k<size
+      incr = 2*k
+      mul = Complex.polar 1, Math::PI/k
+      w = Complex(1, 0)
+      k.times do |i|
+        i.step(size-1,incr) do |j|
+          tmp =  w * vals[j+k]
+          vals[j+k],vals[j]=vals[j]-tmp,vals[j]+tmp
+        end
+        w *= mul;
+      end
+      k=incr
+    end
+    vals
   end
+  module_function :dft
 end

data/lib/ruby_impl/mel_filter.rb

@@ -1,4 +1,5 @@
-require 'noyes_math'
+require 'common/noyes_math'
+
 module Noyes
   # Mel filter takes an m x n matrix.  The inner array becomes equal to the
   # number of mel filter banks (nfilt).  The dimensionality of the outer array

data/lib/ruby_impl/power_spec.rb

@@ -1,17 +1,16 @@
-require 'discrete_fourier_transform'
+require 'ruby_impl/discrete_fourier_transform'
 module Noyes
   # The square of the DFT.  You must specify the number of ffts.  The power
   # spectrum returns an array of arrays where each inner array is of length
   # nfft/2 + 1.  The length of the outer array does not change.
   class PowerSpectrumFilter
-    include Noyes
     def initialize nfft
       @nfft = nfft
     end
     def << data
     	nuniqdftpts = @nfft/2 + 1
     	data.map do |datavec|
-    		datavecfft = dft datavec, @nfft
+    		datavecfft = Noyes.dft datavec, @nfft
     		Array.new(nuniqdftpts){|i| datavecfft[i].abs**2}
     	end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: noyes
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  version: 0.6.1
 platform: ruby
 authors: 
 - Joe Woelfel
@@ -9,29 +9,43 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-03 00:00:00 -05:00
+date: 2010-02-25 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
-description: Currently sufficient to create basic features for speech recognition
+description: Currently sufficient to create features for speech recognition
 email: joe@talkhouse.com
 executables: 
-- noyes_dump44k.sh
-- noyes_dump8k.sh
-- recognize.sh
+- noyes_dump44k
+- noyes_dump8k
+- nrec
 extensions: []
 
 extra_rdoc_files: 
 - COPYING
+- FAQ
 - README
-- doc/overview.rdoc
 files: 
+- lib/common.rb
 - lib/common/noyes_dsl.rb
 - lib/common/noyes_math.rb
 - lib/common/parallel_filter.rb
 - lib/common/send_incrementally.rb
 - lib/common/serial_filter.rb
+- lib/java_impl/dct.rb
+- lib/java_impl/delta.rb
+- lib/java_impl/discrete_fourier_transform.rb
+- lib/java_impl/filter.rb
+- lib/java_impl/hamming_window.rb
+- lib/java_impl/java_filter.rb
+- lib/java_impl/live_cmn.rb
+- lib/java_impl/log_compress.rb
+- lib/java_impl/mel_filter.rb
+- lib/java_impl/power_spec.rb
+- lib/java_impl/preemphasis.rb
+- lib/java_impl/segment.rb
 - lib/noyes.rb
+- lib/noyes_java.rb
 - lib/ruby_impl/dct.rb
 - lib/ruby_impl/delta.rb
 - lib/ruby_impl/discrete_fourier_transform.rb
@@ -43,9 +57,10 @@ files:
 - lib/ruby_impl/power_spec.rb
 - lib/ruby_impl/preemphasis.rb
 - lib/ruby_impl/segment.rb
+- ship/noyes.jar
 - COPYING
+- FAQ
 - README
-- doc/overview.rdoc
 has_rdoc: true
 homepage: http://github.com/talkhouse/noyes
 licenses: []
@@ -54,9 +69,8 @@ post_install_message:
 rdoc_options: 
 - --charset=UTF-8
 require_paths: 
-- lib/ruby_impl
-- lib/common
 - lib
+- ship
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="

data/bin/recognize.sh

@@ -1,15 +0,0 @@
-#!/usr/bin/env jruby
-# vim: set filetype=ruby :
-ROOT = File.dirname(File.dirname(__FILE__))
-$: << "#{ROOT}/lib/ruby"
-$: << "#{ROOT}/lib/common"
-require 'socket'
-require 'send_incrementally'
-
-def recognize file, node='localhost', port=2318
-  TCPSocket.open(node, port) do |client|
-    send_incremental_features file, client, client
-  end
-end
-
-puts recognize ARGV[0]

data/doc/overview.rdoc

@@ -1,51 +0,0 @@
-# = Overview
-#
-# All signal processing routines use a simple DSL style inteface.  Below are
-# some examples.
-#
-# == Filter operator example.
-# Each example below is the data on the left being operated on by the filter on
-# the right.  This is similar to the way the += operator works for numbers. The
-# data is not modified in place currently and it should probably stay that way.
-# It could be if efficiency demanded it, but that would require a bit more care
-# to avoid side effects when using the API.  The >>= actually looks like a
-# filter.  
-#
-#   data = (1..12).to_a
-#   segmenter = Segmenter.new 4, 2 # window size, window shift 
-#   hamming_filter = HammingWindow.new 4 # window size
-#   power_spec_filter = PowerSpectrumFilter.new 8 # number of ffts
-#
-#   data >>= segmenter
-#   data >>= hamming_filter
-#   data >>= power_spec_filter
-#   data >>= dct_filter
-#
-# You can expand the >>= operator out, but I think the flow is worse and there
-# is more repetition, particularly when you have a lot of filters in sequence.
-# This is perfectly valid syntax though. Also, this is very useful if you don't
-# want to keep a reference to your original data.
-#
-#   pcm_data = (1..12).to_a
-#   segmenter = Segmenter.new
-#   hamming_filter = HammingWindow.new 4
-#   segmented_data = segmenter << pcm_data, 4, 2
-#   hamming_data = hamming_filter <<  segmented_data
-#   power_spectrum data = power_spec_filter hamminging_data, 8
-#   dct_data = dct_filter << power_spectrum_data
-#
-# Here is an older version with function calls instead of operator overloading.
-# The trouble with it is that the flow is hard to follow, and there is
-# repetition.  Filter and process are really synonyms. And this requires
-# repeating the data component twice.   Also, power spec is a function here
-# with additional arguments.  I think I'd rather have the configuration
-# details, such as number of ffts all grouped at the top.  It's easier to
-# follow this way.
-#
-#   data = (1..12).to_a
-#   seg = Segmenter.new
-#   ham = HammingWindow.new 4
-#   segments = segmenter.process data, 4, 2
-#   hamming_ = hamming_filter.process segments
-#   power = power_spec.filter hamming, 8
-#   dct = dct.process power