cowboy 0.0.1 → 0.0.2

data/.gitignore

@@ -15,3 +15,7 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.bundle
+*.o
+*.log
+ext/cowboy/Makefile

data/README.md

@@ -1,9 +1,18 @@
 # Cowboy
 
-TODO: Write a gem description
+This is a Ruby wrapper for [FFTW3](http://fftw.org). It currently only
+supports 1-dimension transforms, but I'll be adding support for
+multiple dimensions soon.
 
 ## Installation
 
+### Prerequisites
+
+[FFTW3](http://fftw.org) is required. You can generally get it from
+your OS's package manager (e.g. `sudo port install fftw3`).
+
+### Gem installation
+
 Add this line to your application's Gemfile:
 
     gem 'cowboy'
@@ -18,7 +27,30 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+After installing, you can call `Cowboy::fft_1d` with a 1d array of
+real numbers. This will return an array of complex numbers. Note that
+your input array will be blanked out.
+
+### Windowing
+
+`Cowboy::fft` will do some windowing before calling `fft_1d`. This
+currently behaves somewhat unintelligently and discards points around
+the end of the array (for window size N, it discards N/2 from the
+beginning and N/2 from the end) to allow for a full window at every
+point.
+
+The default is to use a
+[Hamming Window](http://en.wikipedia.org/wiki/Window_function#Hamming_window)
+with a window size of 29. This is configurable as the second and third
+arguments to `fft`. (e.g. `Cowboy::fft(my_array, my_windowing_func,
+12)`)
+
+### Shifting
+
+`Cowboy::Frequencies` is a class that, initialized an array of complex
+numbers (ideally the output of a call to `fft`), will shift them to
+their correct order (e.g. `[-nyquist, +nyquist]`). There is also a
+function `buckets` that will give you the frequency buckets in order.
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,40 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+require 'rake/testtask'
+require 'rake/clean'
+
+NAME = 'cowboy'
+
+# rule to build the extension: this says
+# that the extension should be rebuilt
+# after any change to the files in ext
+file "lib/#{NAME}/#{NAME}.bundle" =>
+  Dir.glob("ext/#{NAME}/*{.rb,.c}") do
+  Dir.chdir("ext/#{NAME}") do
+    # this does essentially the same thing
+    # as what RubyGems does
+    ruby "extconf.rb"
+    sh "make"
+  end
+  cp "ext/#{NAME}/#{NAME}.bundle", "lib/#{NAME}"
+end
+
+# make the :test task depend on the shared
+# object, so it will be built automatically
+# before running the tests
+task :test => "lib/#{NAME}/#{NAME}.bundle"
+
+# use 'rake clean' and 'rake clobber' to
+# easily delete generated files
+CLEAN.include('ext/**/*{.o,.log,.so,.bundle}')
+CLEAN.include('ext/**/Makefile')
+CLOBBER.include('lib/**/*{.so,.bundle}')
+
+# the same as before
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/cowboy.gemspec

@@ -4,9 +4,11 @@ require File.expand_path('../lib/cowboy/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Alejandro Ciniglio"]
   gem.email         = ["mail@alejandrociniglio.com"]
-  gem.description   = %q{gem description}
-  gem.summary       = %q{gem summary}
-  gem.homepage      = ""
+  gem.description   = %q{Cowboy is a wrapper for fftw
+                         (C fourier transform library)}
+  gem.summary       = %q{Cowboy allows you to access
+                         blazing fast FFTs from within Ruby}
+  gem.homepage      = "https://github.com/ciniglio/cowboy"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/ext/cowboy/cowboy.c

@@ -2,34 +2,34 @@
 
 VALUE mCowboy;
 
-VALUE fft_1d(VALUE m, VALUE nums){
+VALUE fft_1d(VALUE m, VALUE v) {
   fftw_complex *in, *out;
   fftw_plan fp;
-  long n;
+  int n;
 
-  Check_Type(nums, T_ARRAY);
-
-  n = size_of_ary(nums);
-  if (n == 0){
-    rb_raise(rb_eException, "Can't use blank array");
+  n = (int) size_of_val(v);
+  if (n == 0) {
+    rb_raise(rb_eException, "Can't use empty set of samples");
   }
+
   in = allocate_fftw_complex(n);
   out = allocate_fftw_complex(n);
   fp = fftw_plan_dft_1d(n, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
 
-  cast_nums_to_complex(in, nums);
+  cast_val_to_complex(in, v);
 
   fftw_execute(fp);
   free(in);
   fftw_destroy_plan(fp);
 
-  return complex_to_real_nums(out, n);
+  return ca_wrap_struct_class(out, n);
 }
 
-void Init_cowboy(){
+void Init_cowboy() {
   mCowboy = rb_define_module("Cowboy");
 
   Init_cowboy_complex();
+  Init_cowboy_array();
 
   rb_define_module_function(mCowboy, "fft_1d", fft_1d, 1);
 }

data/ext/cowboy/cowboy.h

@@ -5,6 +5,7 @@
 #include <fftw3.h>;
 
 #include "cowboy_complex.h";
+#include "cowboy_array.h";
 
 extern VALUE mCowboy;
 

data/ext/cowboy/cowboy_array.c

@@ -0,0 +1,69 @@
+#include "cowboy.h"
+#include <ruby.h>
+
+VALUE cCowboyArray;
+
+typedef struct cowboy_array {
+  long N;
+  fftw_complex* fc;
+} CowboyArray;
+
+static void ca_free(void * ca){
+  free(((CowboyArray *)ca)->fc);
+  free(ca);
+}
+
+VALUE array_index(VALUE self, VALUE index){
+  fftw_complex * fc;
+  CowboyArray * ca;
+  long i = NUM2LONG(index);
+  Data_Get_Struct(self, CowboyArray, ca);
+  if (i >= ca->N){
+    return Qnil;
+  }
+  return c_to_rb_complex(ca->fc[i][0],
+                         ca->fc[i][1]);
+}
+
+VALUE array_size(VALUE self){
+  fftw_complex * fc;
+  CowboyArray * ca;
+  Data_Get_Struct(self, CowboyArray, ca);
+  return LONG2NUM(ca->N);
+}
+
+VALUE array_each(VALUE self){
+  int i;
+  fftw_complex * fc;
+  CowboyArray * ca;
+  Data_Get_Struct(self, CowboyArray, ca);
+
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "Expected Block");
+
+  for(i = 0; i < ca->N; i++)
+    rb_yield(c_to_rb_complex(ca->fc[i][0],
+                             ca->fc[i][1]));
+  return self;
+}
+
+VALUE ca_wrap_struct_class(fftw_complex *fc, long N){
+  CowboyArray * ca;
+  ca = ALLOC(CowboyArray);
+  ca->N = N;
+  ca->fc = fc;
+  return Data_Wrap_Struct(cCowboyArray, 0, free, ca);
+}
+
+VALUE ca_not_implemented(VALUE self){
+  rb_notimplement();
+}
+
+void Init_cowboy_array(){
+  cCowboyArray = rb_define_class_under(mCowboy, "CowboyArray", rb_cObject);
+  rb_define_method(cCowboyArray, "initialize", ca_not_implemented, 0);
+  rb_define_method(cCowboyArray, "size", array_size, 0);
+  rb_define_method(cCowboyArray, "[]", array_index, 1);
+  rb_define_method(cCowboyArray, "each", array_each, 0);
+  rb_include_module(cCowboyArray, rb_mEnumerable);
+}

data/ext/cowboy/cowboy_array.h

@@ -0,0 +1,7 @@
+#ifndef RUBY_COWBOY_ARRAY
+#define RUBY_COWBOY_ARRAY
+
+extern VALUE cCowboyArray;
+void Init_cowboy_array();
+VALUE ca_wrap_struct_class(fftw_complex *fc, long N);
+#endif

data/ext/cowboy/cowboy_complex.c

@@ -1,11 +1,48 @@
 #include "cowboy.h"
 #include <ruby.h>
+#include <stdlib.h>
 
 long size_of_ary(VALUE nums){
   Check_Type(nums, T_ARRAY);
   return RARRAY_LEN(nums);
 }
 
+long size_of_str(VALUE str){
+  Check_Type(str, T_STRING);
+  return RSTRING_LEN(RSTRING(str)) / 8;
+}
+
+long size_of_val(VALUE v){
+  if (TYPE(v) == T_STRING) {
+    return size_of_str(v);
+  } else if (TYPE(v) == T_ARRAY) {
+    return size_of_ary(v);
+  } else {
+    rb_raise(rb_eNotImpError, "Needs a string or array");
+    return 0;
+  }
+}
+
+void cast_string_to_complex(fftw_complex * fc, VALUE str){
+  unsigned char * s;
+  long len;
+  int i, j, a;
+  double d;
+  void *p;
+  double t = 2.3;
+
+  p = &d;
+
+  s = RSTRING_PTR(RSTRING(str));
+  len = RSTRING_LEN(RSTRING(str));
+
+  for(i = 0, j = 0; i < len; i+=8, j++){
+    d = *(double *) &s[i];
+    fc[j][0] = d;
+    fc[j][1] = 0;
+  }
+}
+
 void cast_nums_to_complex(fftw_complex * fc, VALUE nums){
   long len;
   int i;
@@ -13,10 +50,20 @@ void cast_nums_to_complex(fftw_complex * fc, VALUE nums){
   Check_Type(nums, T_ARRAY);
   i = 0;
 
-  while((n =rb_ary_shift(nums)) != Qnil){
-    fc[i][0] = NUM2DBL(n);
-    fc[i][1] = 0;
-    i++;
+  for(len = 0; len < size_of_ary(nums); len++){
+    n = rb_ary_entry(nums, len);
+    fc[len][0] = NUM2DBL(n);
+    fc[len][1] = 0;
+  }
+}
+
+void cast_val_to_complex(fftw_complex * fc, VALUE v){
+  if (TYPE(v) == T_STRING) {
+    cast_string_to_complex(fc, v);
+  } else if (TYPE(v) == T_ARRAY) {
+    cast_nums_to_complex(fc, v);
+  } else {
+    rb_raise(rb_eNotImpError, "Needs a string or array");
   }
 }
 
@@ -32,25 +79,5 @@ VALUE c_to_rb_complex(double r, double i){
                     DBL2NUM(r), DBL2NUM(i));
 }
 
-VALUE complex_to_real_nums(fftw_complex *fc, long N){
-  VALUE ar = rb_ary_new();
-  int i;
-  for(i = 0; i < N; i++){
-    rb_ary_push(ar, c_to_rb_complex(fc[i][0],
-                                    fc[i][1]));
-  }
-  return ar;
-}
-
-VALUE test_back_and_from_complex(VALUE m, VALUE nums){
-  Check_Type(nums, T_ARRAY);
-  fftw_complex * fc;
-  fc = allocate_fftw_complex(size_of_ary(nums));
-  cast_nums_to_complex(fc, nums);
-  return complex_to_real_nums(fc,
-                              size_of_ary(nums));
-}
-
 void Init_cowboy_complex(){
-  rb_define_module_function(mCowboy, "test_complex", test_back_and_from_complex, 1);
 }

data/ext/cowboy/cowboy_complex.h

@@ -5,10 +5,11 @@
 
 void Init_cowboy_complex();
 
-void cast_nums_to_complex(fftw_complex * fc, VALUE nums);
+long size_of_val(VALUE v);
+void cast_val_to_complex(fftw_complex * fc, VALUE v);
+
 fftw_complex * allocate_fftw_complex(long n);
-VALUE complex_to_real_nums(fftw_complex * fc, long N);
-long size_of_ary(VALUE nums);
 
+VALUE c_to_rb_complex(double r, double i);
 
 #endif

data/lib/cowboy.rb

@@ -1,6 +1,7 @@
+require 'cowboy/cowboy'
 require "cowboy/version"
 
-require 'cowboy/cowboy'
+
 module Cowboy
   # Your code goes here...
 end

data/lib/cowboy/fft.rb

@@ -16,13 +16,17 @@ module Cowboy
     end
 
     def buckets(sample_rate=nil)
+      return @buckets if @buckets
       sample_rate ||= @freq.size
       nyquist = sample_rate/2.0
+      sum = 0
       a = []
       n = @freq.size
       for i in (0...n)
-        a << -nyquist + (2 * nyquist/n) * i
+        a << -nyquist + sum
+        sum += (2 * nyquist/n)
       end
+      @buckets = a
       return a
     end
   end

data/lib/cowboy/version.rb

@@ -1,3 +1,3 @@
 module Cowboy
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/test_array.rb

@@ -0,0 +1,27 @@
+require_relative './test_helper.rb'
+
+require 'cowboy'
+require 'test/unit'
+
+class TestArray < Test::Unit::TestCase
+  def test_version
+    assert_not_nil Cowboy::VERSION
+  end
+
+  def test_ffd_1d_4
+    a = [1,2,3,4]
+    c = Cowboy::fft_1d a
+    assert_equal c[0], 10
+    assert_equal c[1], Complex(-2,2)
+    assert_equal c[2], Complex(-2,0)
+    assert_equal c[3], Complex(-2,-2)
+  end
+
+  def test_ffd_1d_8
+    a = [1,2,1,2,1,2,1,2]
+    c = Cowboy::fft_1d a
+    assert_equal c[0], 12
+    assert_equal c[1], 0
+    assert_equal c[4], -4
+  end
+end

data/test/test_enumerable.rb

@@ -0,0 +1,26 @@
+require_relative './test_helper.rb'
+
+class TestEnumerable < Test::Unit::TestCase
+  def test_size
+    a = (0...10000).to_a
+    c = Cowboy::fft_1d a
+    assert_equal c.size, a.size
+  end
+
+  def test_each
+    a = (0...4).to_a
+    c = Cowboy::fft_1d a
+    assert_equal (c.respond_to? :each), true
+    assert_block do
+      c.each do |i|
+        assert_not_nil i
+      end
+    end
+  end
+
+  def test_map
+    a = (0...10).to_a
+    c = Cowboy::fft_1d a
+    assert_equal (c.respond_to? :map), true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../ext', __FILE__)
+
+require 'cowboy'
+require 'test/unit'

data/test/test_string.rb

@@ -0,0 +1,22 @@
+require_relative './test_helper.rb'
+require 'cowboy'
+require 'test/unit'
+
+class TestString < Test::Unit::TestCase
+  def test_ffd_1d_4
+    a = [1,2,3,4].pack('D*')
+    c = Cowboy::fft_1d a
+    assert_equal c[0], 10
+    assert_equal c[1], Complex(-2,2)
+    assert_equal c[2], Complex(-2,0)
+    assert_equal c[3], Complex(-2,-2)
+  end
+
+  def test_ffd_1d_8
+    a = [1,2,1,2,1,2,1,2].pack('D*')
+    c = Cowboy::fft_1d a
+    assert_equal c[0], 12
+    assert_equal c[1], 0
+    assert_equal c[4], -4
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cowboy
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-01 00:00:00.000000000 Z
+date: 2012-11-06 00:00:00.000000000 Z
 dependencies: []
-description: gem description
+description: ! "Cowboy is a wrapper for fftw\n                         (C fourier
+  transform library)"
 email:
 - mail@alejandrociniglio.com
 executables: []
@@ -27,6 +28,8 @@ files:
 - cowboy.gemspec
 - ext/cowboy/cowboy.c
 - ext/cowboy/cowboy.h
+- ext/cowboy/cowboy_array.c
+- ext/cowboy/cowboy_array.h
 - ext/cowboy/cowboy_complex.c
 - ext/cowboy/cowboy_complex.h
 - ext/cowboy/extconf.rb
@@ -34,7 +37,11 @@ files:
 - lib/cowboy/fft.rb
 - lib/cowboy/hamming.rb
 - lib/cowboy/version.rb
-homepage: ''
+- test/test_array.rb
+- test/test_enumerable.rb
+- test/test_helper.rb
+- test/test_string.rb
+homepage: https://github.com/ciniglio/cowboy
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -57,5 +64,9 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: gem summary
-test_files: []
+summary: Cowboy allows you to access blazing fast FFTs from within Ruby
+test_files:
+- test/test_array.rb
+- test/test_enumerable.rb
+- test/test_helper.rb
+- test/test_string.rb