noyes 0.3.2

data/COPYING

@@ -0,0 +1,21 @@
+Copyright 2010 Talkhouse. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this list of
+      conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright notice, this list
+      of conditions and the following disclaimer in the documentation and/or other materials
+      provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY TALKHOUSE ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL TALKHOUSE OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,32 @@
+Noyes is a signal processing library.  It currently has just enough signal
+processing to produce features suitable for speech recognition.
+
+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 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
+disentangled from the overall system that anyone could extract any of the
+routines and use them elsewhere with little trouble.  Benchmarks are included.
+
+This library places an emphasis on expressiveness without sacrificing ultimate
+performance.  It does so by supporting multiple implementations each with Ruby
+bindings.  The pure Ruby version, while not fast, is often adequate for
+development and is the best place to add new routines.    
+
+For examples of how to link with different implementations see the test section
+of the Rakefile.  At present only the pure Ruby implementation is exposed via
+the gem.
+
+Requirements:
+  Almost any version of ruby & rake.
+  Java, if you want to use the Java version.
+
+  Some of the utility scripts may use sox, but
+  none of the core routines use it.
+
+For usage information:
+  rake -T

data/bin/noyes_dump44k.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# vim: set filetype=ruby :
+ROOT = File.dirname(File.dirname(__FILE__))
+$: << "#{ROOT}/lib/ruby"
+$: << "#{ROOT}/lib/common"
+
+require 'signal'
+
+if ARGV.size != 1 || ARGV[0] == '-h'
+  puts "Usage: noyes_dump44k <file>"  
+  exit 1
+end
+
+FILE = ARGV[0]
+DIR = File.dirname FILE
+
+include Signal
+nfilt = 40
+min_freq = 130
+max_freq = 6800
+nfft = 2048
+freq = 44100
+shift = 441
+frame_size = 1130
+
+preemphasizer = Preemphasizer.new 0.97
+segmenter = Segmenter.new frame_size, shift
+hamming_windower = HammingWindow.new frame_size
+power_spectrum_filter = PowerSpectrumFilter.new nfft
+mel_filter = MelFilter.new freq, nfft, nfilt, min_freq, max_freq
+discrete_cosine_transform = DCT.new 13, nfilt
+live_cmn = LiveCMN.new
+ddf = DoubleDeltaFilter.new
+
+raw = `sox #{FILE} -s -B -r 8k -b 16 -t raw -` 
+open('raw.dat', 'wb') {|f| f.write raw}
+pcm = raw.unpack 'n*'
+pcm = pcm.map{|d| to_signed_short(d).to_f}
+pre = preemphasizer << pcm
+open("#{DIR}/pre.dat", 'w') {|f| f.write pre.flatten.pack 'g*' }
+seg = segmenter << (pre + Array.new(frame_size - pre.size % frame_size, 0.0))
+open("#{DIR}/seg.dat", 'w') {|f| f.write seg.flatten.pack 'g*'}
+ham = hamming_windower << seg
+open("#{DIR}/ham.dat", 'w') {|f| f.write ham.flatten.pack 'g*'}
+pow = power_spectrum_filter << ham
+open("#{DIR}/pow.dat", 'w') {|f| f.write pow.flatten.pack 'g*'}
+mel = mel_filter << pow
+open("#{DIR}/mel.dat", 'w') {|f| f.write mel.flatten.pack 'g*'}
+log = log_compress mel
+open("#{DIR}/log_mel.dat", 'w') {|f| f.write log.flatten.pack 'g*'}
+dct = discrete_cosine_transform << log
+open("#{DIR}/dct.dat", 'w') {|f| f.write dct.flatten.pack 'g*'}
+cmn = live_cmn << dct
+open("#{DIR}/cmn.dat", 'w') {|f| f.write cmn.flatten.pack 'g*'}
+dd = ddf << cmn
+dd += ddf.final_estimate
+open("#{DIR}/dd.dat", 'w') {|f| f.write dd.flatten.pack 'g*'}
+
+

data/bin/noyes_dump8k.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# vim: set filetype=ruby :
+ROOT = File.dirname(File.dirname(__FILE__))
+$: << "#{ROOT}/lib/ruby"
+$: << "#{ROOT}/lib/common"
+
+require 'signal'
+
+if ARGV.size != 1 || ARGV[0] == '-h'
+  puts "Usage: noyes_dump8k <file>"  
+  exit 1
+end
+
+FILE = ARGV[0]
+DIR = File.dirname FILE
+
+include Signal
+nfilt = 32
+min_freq = 200
+max_freq = 3700
+nfft = 256
+freq = 8000
+shift = 80
+frame_size = 205
+
+preemphasizer = Preemphasizer.new 0.97
+segmenter = Segmenter.new frame_size, shift
+hamming_windower = HammingWindow.new frame_size
+power_spectrum_filter = PowerSpectrumFilter.new nfft
+mel_filter = MelFilter.new freq, nfft, nfilt, min_freq, max_freq
+discrete_cosine_transform = DCT.new 13, nfilt
+live_cmn = LiveCMN.new
+ddf = DoubleDeltaFilter.new
+
+raw = `sox #{FILE} -s -B -r 8k -b 16 -t raw -` 
+open('raw.dat', 'wb') {|f| f.write raw}
+pcm = raw.unpack 'n*'
+pcm = pcm.map{|d| to_signed_short(d).to_f}
+pre = preemphasizer << pcm
+open("#{DIR}/pre.dat", 'w') {|f| f.write pre.flatten.pack 'g*' }
+seg = segmenter << (pre + Array.new(frame_size - pre.size % frame_size, 0.0))
+open("#{DIR}/seg.dat", 'w') {|f| f.write seg.flatten.pack 'g*'}
+ham = hamming_windower << seg
+open("#{DIR}/ham.dat", 'w') {|f| f.write ham.flatten.pack 'g*'}
+pow = power_spectrum_filter << ham
+open("#{DIR}/pow.dat", 'w') {|f| f.write pow.flatten.pack 'g*'}
+mel = mel_filter << pow
+open("#{DIR}/mel.dat", 'w') {|f| f.write mel.flatten.pack 'g*'}
+log = log_compress mel
+open("#{DIR}/log_mel.dat", 'w') {|f| f.write log.flatten.pack 'g*'}
+dct = discrete_cosine_transform << log
+open("#{DIR}/dct.dat", 'w') {|f| f.write dct.flatten.pack 'g*'}
+cmn = live_cmn << dct
+open("#{DIR}/cmn.dat", 'w') {|f| f.write cmn.flatten.pack 'g*'}
+dd = ddf << cmn
+dd += ddf.final_estimate
+open("#{DIR}/dd.dat", 'w') {|f| f.write dd.flatten.pack 'g*'}
+

data/bin/recognize.sh

@@ -0,0 +1,15 @@
+#!/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

@@ -0,0 +1,51 @@
+# = 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 

data/lib/common/noyes_dsl.rb

@@ -0,0 +1,6 @@
+class Array
+  # The magic that enables the filter operator.
+  def >> other
+    other << self
+  end
+end

data/lib/common/noyes_math.rb

@@ -0,0 +1,18 @@
+module Math
+  def dot_product l1, l2
+    sum = 0
+    for i in 0...l1.size
+      sum += l1[i] * l2[i]
+    end
+    sum
+  end
+end
+
+# Converts from unsigned to signed short.  Ruby, strangely enough, doesn't have
+# network byte order short conversion for signed shorts.
+def to_signed_short n
+  length = 16 # bits
+  max = 2**length-1
+  mid = 2**(length-1)
+  n>=mid ? -((n ^ max) + 1) : n
+end

data/lib/common/send_incrementally.rb

@@ -0,0 +1,62 @@
+require 'noyes'
+include Noyes
+
+TMAGIC = '1.0 talkhouse'
+TSTART = [0].pack('N')
+TAUDIO = [1].pack('N')
+TEND = [2].pack('N')
+TDONE = [3].pack('N')
+TCEPSTRA = [4].pack('N')
+
+# Use sox to convert a file of almost any common type int pcm.
+def file2pcm file
+  raw = `sox #{file} -s -B -r 8k -b 16 -t raw -` 
+  length = 16 # bits
+  max = 2**length-1
+  mid = 2**(length-1)
+  to_signed = proc {|n| (n>=mid) ? -((n ^ max) + 1) : n}
+  unpacked = raw.unpack 'n*'
+  unpacked.map{|d| to_signed[d].to_f}
+end
+
+# Takes a file and two IO-like objects.
+def send_incremental_features file, to_server, from_server
+  nfilt = 32
+  min_freq = 200
+  max_freq = 3700
+  nfft = 256
+  freq = 8000
+  shift = 80
+  frame_size = 205
+  preemphasizer = Preemphasizer.new 0.97
+  segmenter = Segmenter.new frame_size, shift
+  hamming_windower = HammingWindow.new frame_size
+  power_spectrum_filter = PowerSpectrumFilter.new nfft
+  mel_filter = MelFilter.new freq, nfft, nfilt, min_freq, max_freq
+  compressor = LogCompressor.new
+  discrete_cosine_transform = DCT.new 13, nfilt
+  live_cmn = LiveCMN.new
+  pcm = file2pcm file
+  to_server.write TMAGIC
+  to_server.write TSTART
+  pcm.each_slice 1230 do |data|
+    data >>= preemphasizer
+    data >>= segmenter
+    next unless data
+    data >>= hamming_windower
+    data >>= power_spectrum_filter
+    data >>= mel_filter
+    data >>= compressor
+    data >>= discrete_cosine_transform
+    data >>= live_cmn
+    to_server.write TCEPSTRA
+    to_server.write [data.size].pack('N')
+    print '.'
+    data.each {|cmn| to_server.write cmn.pack('g*')} 
+    to_server.flush
+  end
+  to_server.write TEND
+  to_server.write TDONE
+  to_server.flush
+  from_server.read
+end

data/lib/noyes.rb

@@ -0,0 +1,13 @@
+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"

data/lib/ruby_impl/dct.rb

@@ -0,0 +1,34 @@
+require 'noyes_math'
+
+module Noyes
+  # Takes the discrete cosing transform.  Converts a n x m matrix to an n x order
+  # matrix.  ncol should be set to m.
+  class DCT 
+    include Math
+    attr_accessor :melcos
+    def initialize order, ncol
+      @melcos = []
+      order.times do |i|
+        freq = PI * i.to_f / ncol
+        ldct = Array.new ncol
+        ncol.times do |j|
+          ldct[j] = cos(freq * (j + 0.5)) / order # [1]
+        end
+        @melcos << ldct
+      end
+      @melcos
+    end
+
+    def << data
+      data.map do |dvec|
+        @melcos.map {|m| dot_product m, dvec}
+      end
+    end
+  end
+end
+
+# Notes:
+# [1]  I'm not sure why I do this division by order.  Sphinx does it.  I wanted
+# to have compatible output though I'm not sure I should care since I don't use
+# sphinx anymore.  However, Sphinx does it continually during processing.  I
+# build it into the filters so there is no cost.  

data/lib/ruby_impl/delta.rb

@@ -0,0 +1,34 @@
+module Noyes
+  # Takes an m x n array and makes an m x 3 x n array.  The original inner
+  # array is duplicated followed by its delta and it's double delta.
+  class DoubleDeltaFilter
+    def initialize
+      @previous = nil
+    end
+    def << cepstra
+      @previous = [cepstra.first] * 3 unless @previous
+      buf = @previous + cepstra
+      result = []
+      for i in 3...(buf.size-3)
+         delta = Array.new buf[i].size
+         delta.size.times do |k|
+           delta[k] = buf[i+2][k] - buf[i-2][k]
+         end
+         double_delta = Array.new buf[i].size
+         double_delta.size.times do |k|
+           double_delta[k] = buf[i+3][k] - buf[i-1][k] - buf[i+1][k] + buf[i-3][k]
+         end
+         result << [buf[i], delta, double_delta]
+      end
+      @previous = buf[-6..-1]
+      result
+    end
+    # If there is no more data we can estimate a couple more frames by copying
+    # the final frame 3 times.  Probably this is rarely necessary.
+    def final_estimate
+      return [] unless @previous
+      cepstra = [@previous.last] * 3
+      self.<< cepstra
+    end
+  end
+end

data/lib/ruby_impl/discrete_fourier_transform.rb

@@ -0,0 +1,37 @@
+require 'complex'
+
+module Noyes
+  include Math
+  # Takes the discrete Fourier transform.
+  def dft data,size
+  	vals = Array.new size
+  	data.size.times {|i| vals[i] = Complex(data[i],0)}
+  	(data.size).upto(size-1) {|i| vals[i] = 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 
+        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
+end

data/lib/ruby_impl/filter.rb

@@ -0,0 +1,11 @@
+module Noyes
+  # A generic filter.  Just supply an array of weights.
+  class Filter
+    def initialize weights
+      @weights = weights
+    end
+    def << data
+      data.zip(@weights).map {|d, h| d*h}
+    end
+  end
+end

data/lib/ruby_impl/hamming_window.rb

@@ -0,0 +1,20 @@
+module Noyes
+  # Takes a m x n matrix and multiples each inner array by a hamming window
+  # function.  Be careful to make sure your inner array length is the same as
+  # the window size.
+  class HammingWindow
+    include Math
+    def initialize window_size
+  	  twopi = 2 * PI
+  	  @hamming_window = []
+      window_size.times do |i|
+  	  	@hamming_window << 0.54 - 0.46*cos(twopi*i/(window_size-1))
+  	  end
+    end
+    def << segments
+      segments.map do |s|
+        s.zip(@hamming_window).map {|d, h| d*h}
+      end
+    end
+  end
+end

data/lib/ruby_impl/live_cmn.rb

@@ -0,0 +1,42 @@
+class LiveCMN
+  # Normalizes cepstrum means and applies them.  Dimensionality remains
+  # unchanged.  NOTE:  This class resets itself automatically if bounds drift
+  # too much.  Possibly these bounds should be parameterized.
+  def initialize dimensions=13, init_mean=45.0, window_size=100, shift=160
+    @init_mean = init_mean; @shift = shift; @ws = window_size
+    @sums = Array.new dimensions, 0
+    @means = Array.new dimensions, 0
+    @means[0] = @init_mean
+    @frame_count = 0
+  end
+  def << dct
+    raise "Wrong number of dimensions" if dct[0].size != @means.size
+    dct.map do |mfc|
+      cmn = Array.new @means.size
+      @means.size.times do |i|
+        @sums[i] += mfc[i]
+        cmn[i] = mfc[i] - @means[i]
+      end
+      @frame_count += 1
+      update if @frame_count > @shift
+      cmn
+    end
+  end
+  def update
+    per_frame = 1.0 / @frame_count
+    @means = @sums.map {|x| x * per_frame}
+    
+    if @means.first > 70 || @means.first < 5
+      reset
+    elsif @frame_count >= @shift
+      @sums = @sums.map {|x| x * per_frame * @ws}
+      @frame_count = @ws
+    end
+  end
+  def reset
+    @sums.map! {0}
+    @means.map! {0}
+    @means[0] = @init_mean
+    @frame_count = 0
+  end
+end

data/lib/ruby_impl/log_compress.rb

@@ -0,0 +1,13 @@
+module Noyes
+  # Takes the log base 10 of an incoming m x n array.  The dimensions of the
+  # array remain unchanged.  If a value is zero then the value log_zero is used
+  # instead of plunging into singularity land and throwing an exception.
+  class LogCompressor
+    def initialize log_zero = -0.00001
+      @log_zero = log_zero
+    end
+    def << mspec
+      mspec.map {|msp| msp.map { |m|  m > 0 ? Math::log(m) : @log_zero}}
+    end
+  end
+end

data/lib/ruby_impl/mel_filter.rb

@@ -0,0 +1,112 @@
+require '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
+  # remains unchanged.
+  class MelFilter  
+    include Math
+    def initialize srate, nfft, nfilt, lowerf, upperf
+      bank_params = MelFilter.make_bank_parameters srate, nfft, nfilt, lowerf, upperf
+      @indices = []
+      @weights = []
+      bank_params.map do |params|
+        ind, weights = MelFilter.make_filter *params
+        @indices << ind
+        @weights << weights
+      end
+    end
+    def << power_spectra
+      power_spectra.map do |spectrum|
+        mel_bank = Array.new @indices.size
+	@indices.size.times do |i|
+	  initial_index, weights = @indices[i], @weights[i]
+	  output = 0.0
+	  weights.size.times do |j|
+	    index = initial_index + j
+	    output += spectrum[index] * weights[j] if index < spectrum.length 
+	  end
+	  mel_bank[i] = output
+	end
+        mel_bank
+      end
+    end
+    def self.to_mel f
+      return f.map {|linfreq| self.to_mel linfreq} if f.respond_to? :map
+      2595.0 * Math.log10(1.0 + f/700.0)
+    end
+    def self.to_linear m
+      return m.map {|melfreq| self.to_linear melfreq} if m.respond_to? :map
+      700.0 * (10.0**(m/2595.0) - 1.0)
+    end
+    def self.determine_bin in_freq, step_freq
+      step_freq * (in_freq/step_freq).round
+    end
+    def self.make_bank_parameters srate, nfft, nfilt, lowerf, upperf
+      raise 'Number of FFT points is <= 0.' if nfft == 0
+      raise 'Number of filters is <= 0.' if nfilt == 0
+      srate = srate.to_f; lowerf = lowerf.to_f; upperf = upperf.to_f
+      left_edge = Array.new nfilt
+      right_edge = Array.new nfilt
+      center_freq = Array.new nfilt
+      melmax = self.to_mel upperf
+      melmin = self.to_mel lowerf
+      delta_freq_mel = (melmax - melmin) / (nfilt + 1.0)
+      delta_freq = srate/nfft
+      left_edge[0] = self.determine_bin lowerf, delta_freq
+      next_edge_mel = melmin
+      nfilt.times do |i|
+        next_edge_mel += delta_freq_mel
+        next_edge = self.to_linear next_edge_mel
+        center_freq[i] = self.determine_bin next_edge, delta_freq
+        right_edge[i-1] = center_freq[i] if i > 0   
+        left_edge[i+1] = center_freq[i] if i < nfilt - 1 
+      end
+
+      next_edge_mel += delta_freq_mel
+      next_edge = self.to_linear next_edge_mel
+      right_edge[nfilt-1] = self.determine_bin next_edge, delta_freq
+      fparams = Array.new nfilt
+      nfilt.times do |i| 
+        initial_freq_bin = self.determine_bin left_edge[i], delta_freq
+        initial_freq_bin += delta_freq if initial_freq_bin < left_edge[i]
+        fparams[i] = [left_edge[i], center_freq[i], right_edge[i], 
+                    initial_freq_bin, delta_freq]
+      end
+      fparams
+    end
+    def self.make_filter left, center, right, init_freq, delta
+      raise 'delta freq has zero value' if delta == 0
+      if (right - left).round == 0 || (center - left).round == 0 ||
+         (right - center).round == 0
+        raise 'filter boundaries too close'
+      end
+ 
+      n_elements = ((right - left)/ delta + 1).round
+      raise 'number of mel elements is zero' if n_elements == 0
+
+      weights = Array.new n_elements    
+      height = 1
+      left_slope = height / (center - left)
+      right_slope = height / (center - right)
+
+      index_fw = 0
+      init_freq.step right, delta do |current|
+        if current < center
+          weights[index_fw] = left_slope * (current - left)
+        else
+          weights[index_fw] = height + right_slope * (current - center) 
+        end
+        index_fw += 1
+      end
+      #weights.insert 0, (init_freq/delta).round
+      [(init_freq/delta).round, weights]
+    end
+    def apply_weights init_index, weights, spectrum
+      output = 0.0
+      weights.size.times do |i|
+        output += spectrum[i + init_index] * weights[i] 
+      end
+      output
+    end
+  end
+end

data/lib/ruby_impl/power_spec.rb

@@ -0,0 +1,19 @@
+require '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
+    		Array.new(nuniqdftpts){|i| datavecfft[i].abs**2}
+    	end
+    end
+  end
+end

data/lib/ruby_impl/preemphasis.rb

@@ -0,0 +1,21 @@
+module Noyes
+  # A simple high pass filter.  It takes an array of size n and returns an
+  # array of size n.
+  class Preemphasizer
+    include Math
+    def initialize factor=0.97
+      @factor = factor
+      @prior = 0
+    end
+
+    def << data
+      prior = @prior
+      @prior = data.last 
+      data.map do |x|
+         y = x - @factor * prior
+         prior = x
+         y
+      end
+    end
+  end
+end 

data/lib/ruby_impl/segment.rb

@@ -0,0 +1,28 @@
+module Noyes
+  # Segments an array of data into an array of arrays.  Inner arrays are the
+  # size of the window.
+  class Segmenter
+    def initialize window_size, shift
+      @winsz = window_size; @winshift = shift
+      @overflow = nil
+    end    
+  
+    def << data
+      data = @overflow + data if @overflow
+      if data.size < @winsz + @winshift * 5
+        @overflow = data
+        return nil 
+      else
+        @overflow = nil 
+      end
+      x = []
+      i = 0
+      while i+@winsz <= data.length
+        x << data[i,@winsz]
+        i += @winshift
+      end
+      @overflow = data[i..-1]
+      x
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: noyes
+version: !ruby/object:Gem::Version 
+  version: 0.3.2
+platform: ruby
+authors: 
+- Joe Woelfel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-01 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Currently sufficient to create basic features for speech recognition
+email: joe@talkhouse.com
+executables: 
+- noyes_dump44k.sh
+- noyes_dump8k.sh
+- recognize.sh
+extensions: []
+
+extra_rdoc_files: 
+- COPYING
+- README
+- doc/overview.rdoc
+files: 
+- lib/common/noyes_dsl.rb
+- lib/common/noyes_math.rb
+- lib/common/send_incrementally.rb
+- lib/noyes.rb
+- lib/ruby_impl/dct.rb
+- lib/ruby_impl/delta.rb
+- lib/ruby_impl/discrete_fourier_transform.rb
+- lib/ruby_impl/filter.rb
+- lib/ruby_impl/hamming_window.rb
+- lib/ruby_impl/live_cmn.rb
+- lib/ruby_impl/log_compress.rb
+- lib/ruby_impl/mel_filter.rb
+- lib/ruby_impl/power_spec.rb
+- lib/ruby_impl/preemphasis.rb
+- lib/ruby_impl/segment.rb
+- COPYING
+- README
+- doc/overview.rdoc
+has_rdoc: true
+homepage: http://github.com/talkhouse/noise
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib/ruby_impl
+- lib/common
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A signal processing library
+test_files: []
+