hornetseye-fftw3 0.1.0

data/README.md

@@ -0,0 +1,28 @@
+hornetseye-fftw3
+================
+
+**Author**:       Jan Wedekind
+**Copyright**:    2011
+**License**:      GPL
+
+Synopsis
+--------
+
+This Ruby extension provides bindings for the FFTW3 library.
+
+Installation
+------------
+
+*hornetseye-fftw3* requires the FFTW3 libraries. If you are running Debian or (K)ubuntu, you can install them like this:
+
+    $ sudo aptitude install libfftw3-dev
+
+To install this Ruby extension, use the following command:
+
+    $ sudo gem install hornetseye-fftw3
+
+Alternatively you can build and install the Ruby extension from source as follows:
+
+    $ rake
+    $ sudo rake install
+

data/Rakefile

@@ -0,0 +1,183 @@
+#!/usr/bin/env ruby
+require 'date'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/loaders/makefile'
+require 'rbconfig'
+require 'tempfile'
+
+PKG_NAME = 'hornetseye-fftw3'
+PKG_VERSION = '0.1.0'
+CFG = RbConfig::CONFIG
+CXX = ENV[ 'CXX' ] || 'g++'
+RB_FILES = FileList[ 'lib/**/*.rb' ]
+CC_FILES = FileList[ 'ext/*.cc' ]
+HH_FILES = FileList[ 'ext/*.hh' ] + FileList[ 'ext/*.tcc' ]
+TC_FILES = FileList[ 'test/tc_*.rb' ]
+TS_FILES = FileList[ 'test/ts_*.rb' ]
+SO_FILE = "ext/#{PKG_NAME.tr '\-', '_'}.#{CFG[ 'DLEXT' ]}"
+PKG_FILES = [ 'Rakefile', 'README.md', 'COPYING', '.document' ] +
+            RB_FILES + CC_FILES + HH_FILES + TS_FILES + TC_FILES
+BIN_FILES = [ 'README.md', 'COPYING', '.document', SO_FILE ] +
+            RB_FILES + TS_FILES + TC_FILES
+SUMMARY = %q{Fourier transforms}
+DESCRIPTION = %q{This Ruby extension provides bindings for the FFTW3 library.}
+AUTHOR = %q{Jan Wedekind}
+EMAIL = %q{jan@wedesoft.de}
+HOMEPAGE = %q{http://wedesoft.github.com/hornetseye-fftw3/}
+
+OBJ = CC_FILES.ext 'o'
+$CXXFLAGS = "-DNDEBUG -DHAVE_CONFIG_H -D__STDC_CONSTANT_MACROS #{CFG[ 'CPPFLAGS' ]} #{CFG[ 'CFLAGS' ]}"
+if CFG[ 'rubyhdrdir' ]
+  $CXXFLAGS = "#{$CXXFLAGS} -I#{CFG[ 'rubyhdrdir' ]} " + 
+              "-I#{CFG[ 'rubyhdrdir' ]}/#{CFG[ 'arch' ]}"
+else
+  $CXXFLAGS = "#{$CXXFLAGS} -I#{CFG[ 'archdir' ]}"
+end
+$LIBRUBYARG = "-L#{CFG[ 'libdir' ]} #{CFG[ 'LIBRUBYARG' ]} #{CFG[ 'LDFLAGS' ]} " +
+              "#{CFG[ 'SOLIBS' ]} #{CFG[ 'DLDLIBS' ]}"
+$SITELIBDIR = CFG[ 'sitelibdir' ]
+$SITEARCHDIR = CFG[ 'sitearchdir' ]
+$LDSHARED = CFG[ 'LDSHARED' ][ CFG[ 'LDSHARED' ].index( ' ' ) .. -1 ]
+
+task :default => :all
+
+desc 'Compile Ruby extension (default)'
+task :all => [ SO_FILE ]
+
+file SO_FILE => OBJ do |t|
+   sh "#{CXX} -shared -o #{t.name} #{OBJ} -lfftw3 -lfftw3f #{$LIBRUBYARG}"
+end
+
+task :test => [ SO_FILE ]
+
+desc 'Install Ruby extension'
+task :install => :all do
+  verbose true do
+    for f in RB_FILES do
+      FileUtils.mkdir_p "#{$SITELIBDIR}/#{File.dirname f.gsub( /^lib\//, '' )}"
+      FileUtils.cp_r f, "#{$SITELIBDIR}/#{f.gsub( /^lib\//, '' )}"
+    end
+    FileUtils.mkdir_p $SITEARCHDIR
+    FileUtils.cp SO_FILE, "#{$SITEARCHDIR}/#{File.basename SO_FILE}"
+  end
+end
+
+desc 'Uninstall Ruby extension'
+task :uninstall do
+  verbose true do
+    for f in RB_FILES do
+      FileUtils.rm_f "#{$SITELIBDIR}/#{f.gsub /^lib\//, ''}"
+    end
+    FileUtils.rm_f "#{$SITEARCHDIR}/#{File.basename SO_FILE}"
+  end
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'ext'
+  t.test_files = TC_FILES
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new :yard do |y|
+    y.files << RB_FILES
+  end
+rescue LoadError
+  STDERR.puts 'Please install \'yard\' if you want to generate documentation'
+end
+
+Rake::PackageTask.new PKG_NAME, PKG_VERSION do |p|
+  p.need_tar = true
+  p.package_files = PKG_FILES
+end
+
+begin
+  require 'rubygems'
+  require 'rubygems/builder'
+  $SPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::RUBY
+    s.date = Date.today.to_s
+    s.summary = SUMMARY
+    s.description = DESCRIPTION
+    s.author = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.files = PKG_FILES
+    s.test_files = TC_FILES
+    s.require_paths = [ 'lib', 'ext' ]
+    s.rubyforge_project = %q{hornetseye}
+    s.extensions = %w{Rakefile}
+    s.has_rdoc = 'yard'
+    s.extra_rdoc_files = []
+    s.rdoc_options = %w{--no-private}
+    s.add_dependency %<malloc>, [ '~> 1.1' ]
+    s.add_dependency %<multiarray>, [ '~> 0.20' ]
+    s.add_development_dependency %q{rake}
+  end
+  GEM_SOURCE = "#{PKG_NAME}-#{PKG_VERSION}.gem"
+  $BINSPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::CURRENT
+    s.date = Date.today.to_s
+    s.summary = SUMMARY
+    s.description = DESCRIPTION
+    s.author = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.files = BIN_FILES
+    s.test_files = TC_FILES
+    s.require_paths = [ 'lib', 'ext' ]
+    s.rubyforge_project = %q{hornetseye}
+    s.has_rdoc = 'yard'
+    s.extra_rdoc_files = []
+    s.rdoc_options = %w{--no-private}
+    s.add_dependency %<malloc>, [ '~> 1.1' ]
+    s.add_dependency %<multiarray>, [ '~> 0.20' ]
+  end
+  GEM_BINARY = "#{PKG_NAME}-#{PKG_VERSION}-#{$BINSPEC.platform}.gem"
+  desc "Build the gem file #{GEM_SOURCE}"
+  task :gem => [ "pkg/#{GEM_SOURCE}" ]
+  file "pkg/#{GEM_SOURCE}" => [ 'pkg' ] + $SPEC.files do
+    when_writing 'Creating GEM' do
+      Gem::Builder.new( $SPEC ).build
+      verbose true do
+        FileUtils.mv GEM_SOURCE, "pkg/#{GEM_SOURCE}"
+      end
+    end
+  end
+  desc "Build the gem file #{GEM_BINARY}"
+  task :gem_binary => [ "pkg/#{GEM_BINARY}" ]
+  file "pkg/#{GEM_BINARY}" => [ 'pkg' ] + $BINSPEC.files do
+    when_writing 'Creating binary GEM' do
+      Gem::Builder.new( $BINSPEC ).build
+      verbose true do
+        FileUtils.mv GEM_BINARY, "pkg/#{GEM_BINARY}"
+      end
+    end
+  end
+rescue LoadError
+  STDERR.puts 'Please install \'rubygems\' if you want to create Gem packages'
+end
+
+rule '.o' => '.cc' do |t|
+   sh "#{CXX} #{$CXXFLAGS} -c -o #{t.name} #{t.source}"
+end
+
+file ".depends.mf" do |t|
+  sh "g++ -MM #{CC_FILES.join ' '} | " +
+    "sed -e :a -e N -e 's/\\n/\\$/g' -e ta | " +
+    "sed -e 's/ *\\\\\\$ */ /g' -e 's/\\$/\\n/g' | sed -e 's/^/ext\\//' > #{t.name}"
+end
+CC_FILES.each do |t|
+  file t.ext(".o") => t
+end
+import ".depends.mf"
+
+CLEAN.include 'ext/*.o'
+CLOBBER.include SO_FILE, 'doc', '.yardoc', '.depends.mf'
+

data/ext/error.hh

@@ -0,0 +1,50 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008, 2009, 2010   Jan Wedekind
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
+#ifndef ERROR_HH
+#define ERROR_HH
+
+#include <exception>
+#include <sstream>
+
+class Error: public std::exception
+{
+public:
+  Error(void) {}
+  Error( Error &e ): std::exception( e )
+    { m_message << e.m_message.str(); }
+  virtual ~Error(void) throw() {}
+  template< typename T >
+  std::ostream &operator<<( const T &t )
+    { m_message << t; return m_message; }
+  std::ostream &operator<<( std::ostream& (*__pf)(std::ostream&) )
+    { (*__pf)( m_message ); return m_message; }
+  virtual const char* what(void) const throw() {
+    temp = m_message.str();
+    return temp.c_str();
+  }
+protected:
+  std::ostringstream m_message;
+  mutable std::string temp;
+};
+
+#define ERRORMACRO( condition, class, params, message ) \
+  if ( !( condition ) ) {                               \
+    class _e params;                                    \
+    _e << message;                                      \
+    throw _e;                                           \
+  };
+
+#endif

data/ext/init.cc

@@ -0,0 +1,38 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011   Jan Wedekind
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
+#include "rubyinc.hh"
+#include "node.hh"
+
+#ifdef WIN32
+#define DLLEXPORT __declspec(dllexport)
+#define DLLLOCAL
+#else
+#define DLLEXPORT __attribute__ ((visibility("default")))
+#define DLLLOCAL __attribute__ ((visibility("hidden")))
+#endif
+
+extern "C" DLLEXPORT void Init_hornetseye_fftw3(void);
+
+extern "C" {
+
+  void Init_hornetseye_fftw3(void)
+  {
+    VALUE rbHornetseye = rb_define_module( "Hornetseye" );
+    Node::registerRubyClass( rbHornetseye );
+    rb_require( "hornetseye_fftw3_ext.rb" );
+  }
+
+}

data/ext/node.cc

@@ -0,0 +1,223 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011   Jan Wedekind
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
+#include <iostream>
+
+#include <boost/shared_array.hpp>
+#include <fftw3.h>
+#include "error.hh"
+#include "node.hh"
+
+using namespace boost;
+using namespace std;
+
+VALUE Node::cRubyClass = Qnil;
+
+VALUE Node::mModule = Qnil;
+
+VALUE Node::registerRubyClass( VALUE module )
+{
+  mModule = module;
+  cRubyClass = rb_define_class_under( module, "Node", rb_cObject );
+  rb_define_method( cRubyClass, "fft", RUBY_METHOD_FUNC( wrapFFT ), 1 );
+  rb_define_method( cRubyClass, "rfft", RUBY_METHOD_FUNC( wrapRFFT ), 1 );
+  return cRubyClass;
+}
+
+VALUE Node::wrapFFT( VALUE rbSelf, VALUE rbForward )
+{
+  VALUE rbRetVal = Qnil;
+  try {
+    int sign = rbForward == Qtrue ? FFTW_FORWARD : FFTW_BACKWARD;
+    VALUE rbMalloc = rb_funcall( rbSelf, rb_intern( "memory" ), 0 );
+    VALUE rbTypecode = rb_funcall( rbSelf, rb_intern( "typecode" ), 0 );
+    VALUE rbSize = rb_funcall( rbSelf, rb_intern( "size" ), 0 );
+    int size = NUM2INT( rbSize );
+    VALUE rbShape = rb_funcall( rbSelf, rb_intern( "shape" ), 0 );
+    int rank = RARRAY_LEN( rbShape );
+    shared_array< int > n( new int[ rank ] );
+    for ( int i=0; i<rank; i++ )
+      n[ rank - 1 - i ] = NUM2INT( RARRAY_PTR( rbShape )[i] );
+    VALUE rbDest = Qnil;
+    if ( rb_funcall( rbTypecode, rb_intern( "==" ), 1,
+                     rb_const_get( mModule, rb_intern( "SCOMPLEX" ) ) ) == Qtrue ) {
+      assert( sizeof( fftwf_complex ) == sizeof( float ) * 2 );
+      fftwf_complex *source;
+      Data_Get_Struct( rbMalloc, fftwf_complex, source );
+      fftwf_complex *dest = ALLOC_N( fftwf_complex, size );
+      rbDest = Data_Wrap_Struct( rb_const_get( mModule, rb_intern( "Malloc" ) ), 0, xfree,
+                                 (void *)dest );
+      rb_ivar_set( rbDest, rb_intern( "@size" ), INT2NUM( size * sizeof( fftwf_complex ) ) );
+      fftwf_plan plan =
+        fftwf_plan_dft( rank, n.get(), source, dest, sign,
+                        FFTW_ESTIMATE | FFTW_PRESERVE_INPUT );
+      ERRORMACRO( plan != NULL, Error, , "Error creating FFTW plan" );
+      fftwf_execute( plan );
+      fftwf_destroy_plan( plan );
+    } else if ( rb_funcall( rbTypecode, rb_intern( "==" ), 1,
+                            rb_const_get( mModule, rb_intern( "DCOMPLEX" ) ) ) == Qtrue ) {
+      assert( sizeof( fftw_complex ) == sizeof( double ) * 2 );
+      fftw_complex *source;
+      Data_Get_Struct( rbMalloc, fftw_complex, source );
+      fftw_complex *dest = ALLOC_N( fftw_complex, size );
+      rbDest = Data_Wrap_Struct( rb_const_get( mModule, rb_intern( "Malloc" ) ), 0, xfree,
+                                 (void *)dest );
+      rb_ivar_set( rbDest, rb_intern( "@size" ), INT2NUM( size * sizeof( fftw_complex ) ) );
+      fftw_plan plan =
+        fftw_plan_dft( rank, n.get(), source, dest, sign,
+                       FFTW_ESTIMATE | FFTW_PRESERVE_INPUT );
+      ERRORMACRO( plan != NULL, Error, , "Error creating FFTW plan" );
+      fftw_execute( plan );
+      fftw_destroy_plan( plan );
+    } else {
+      ERRORMACRO( false, Error, ,
+                  "This datatype is not supported for the selected transform" );
+    };
+    rbRetVal = rb_funcall2( rb_funcall( rb_const_get( mModule, rb_intern( "Sequence" ) ),
+                                        rb_intern( "import" ), 3,
+                                        rbTypecode, rbDest, rbSize ),
+                            rb_intern( "reshape" ), rank, RARRAY_PTR(rbShape) );
+  } catch ( std::exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbRetVal;
+}
+
+VALUE Node::wrapRFFT( VALUE rbSelf, VALUE rbForward )
+{
+  VALUE rbRetVal = Qnil;
+  try {
+    int sign = rbForward == Qtrue ? FFTW_FORWARD : FFTW_BACKWARD;
+    VALUE rbMalloc = rb_funcall( rbSelf, rb_intern( "memory" ), 0 );
+    VALUE rbTypecode = rb_funcall( rbSelf, rb_intern( "typecode" ), 0 );
+    VALUE rbInSize = rb_funcall( rbSelf, rb_intern( "size" ), 0 );
+    int inSize = NUM2INT( rbInSize );
+    VALUE rbShape = rb_funcall( rbSelf, rb_intern( "shape" ), 0 );
+    int rank = RARRAY_LEN( rbShape );
+    shared_array< int > n( new int[ rank ] );
+    for ( int i=0; i<rank; i++ )
+      n[ rank - 1 - i ] = NUM2INT( RARRAY_PTR( rbShape )[i] );
+    VALUE rbDest = Qnil;
+    VALUE rbRetType = Qnil;
+    int size = 0;
+    if ( rank > 0 ) {
+      if ( sign == FFTW_FORWARD ) {
+        ERRORMACRO( n[ rank - 1 ] % 2 == 0, Error, ,
+                    "First dimension of array must be even for discrete "
+                    "fourier transform of real data" );
+        int half = n[ rank - 1 ] / 2 + 1;
+        size = inSize / n[ rank - 1 ] * half;
+        RARRAY_PTR(rbShape)[0] = INT2NUM(half);
+      } else {
+        int twice = ( n[ rank - 1 ] - 1 ) * 2;
+        size = inSize / n[ rank - 1 ] * twice;
+        RARRAY_PTR(rbShape)[0] = INT2NUM(twice);
+        n[ rank - 1 ] = twice;
+      };
+    };
+    if ( ( rb_funcall( rbTypecode, rb_intern( "==" ), 1,
+                       rb_const_get( mModule,
+                                     rb_intern( "SFLOAT" ) ) ) ==
+           Qtrue &&
+           sign == FFTW_FORWARD ) ||
+         ( rb_funcall( rbTypecode, rb_intern( "==" ), 1,
+                       rb_const_get( mModule,
+                                     rb_intern( "SCOMPLEX" ) ) ) ==
+           Qtrue &&
+           sign == FFTW_BACKWARD ) ) {
+      assert( sizeof( fftwf_complex ) == sizeof( float ) * 2 );
+      fftwf_complex *source;
+      Data_Get_Struct( rbMalloc, fftwf_complex, source );
+      void *dest;
+      fftwf_plan plan;
+      shared_array< fftwf_complex > copy;
+      int retTypeSize;
+      if ( sign == FFTW_FORWARD ) {
+        dest = ALLOC_N( fftwf_complex, size );
+        retTypeSize = sizeof( fftwf_complex );
+        plan = fftwf_plan_dft_r2c( rank, n.get(), (float *)source,
+                                   (fftwf_complex *)dest,
+                                   FFTW_ESTIMATE | FFTW_PRESERVE_INPUT );
+        rbRetType = rb_const_get( mModule, rb_intern( "SCOMPLEX" ) );
+      } else {
+        dest = ALLOC_N( float, size );
+        retTypeSize = sizeof( float );
+        // FFTW_PRESERVE_INPUT not supported in this case.
+        copy = shared_array< fftwf_complex >( new fftwf_complex[ inSize ] );
+        memcpy( copy.get(), source, inSize * sizeof( fftwf_complex ) );
+        plan = fftwf_plan_dft_c2r( rank, n.get(), (fftwf_complex *)copy.get(),
+                                   (float *)dest, FFTW_ESTIMATE );
+        rbRetType = rb_const_get( mModule, rb_intern( "SFLOAT" ) );
+      };
+      rbDest = Data_Wrap_Struct( rb_const_get( mModule, rb_intern( "Malloc" ) ), 0, xfree,
+                                 (void *)dest );
+      rb_ivar_set( rbDest, rb_intern( "@size" ), INT2NUM( size * retTypeSize ) );
+      ERRORMACRO( plan != NULL, Error, , "Error creating FFTW plan" );
+      fftwf_execute( plan );
+      fftwf_destroy_plan( plan );
+    } else if ( ( rb_funcall( rbTypecode, rb_intern( "==" ), 1,
+                              rb_const_get( mModule,
+                                            rb_intern( "DFLOAT" ) ) ) ==
+                  Qtrue &&
+                  sign == FFTW_FORWARD ) ||
+                ( rb_funcall( rbTypecode, rb_intern( "==" ), 1,
+                              rb_const_get( mModule,
+                                            rb_intern( "DCOMPLEX" ) ) ) ==
+                  Qtrue &&
+                  sign == FFTW_BACKWARD ) ) {
+      assert( sizeof( fftw_complex ) == sizeof( double ) * 2 );
+      fftw_complex *source;
+      Data_Get_Struct( rbMalloc, fftw_complex, source );
+      void *dest;
+      fftw_plan plan;
+      shared_array< fftw_complex > copy;
+      int retTypeSize;
+      if ( sign == FFTW_FORWARD ) {
+        dest = ALLOC_N( fftw_complex, size );
+        retTypeSize = sizeof( fftw_complex );
+        plan = fftw_plan_dft_r2c( rank, n.get(), (double *)source,
+                                  (fftw_complex *)dest,
+                                  FFTW_ESTIMATE | FFTW_PRESERVE_INPUT );
+        rbRetType = rb_const_get( mModule, rb_intern( "DCOMPLEX" ) );
+      } else {
+        dest = ALLOC_N( double, size );
+        retTypeSize = sizeof( double );
+        // FFTW_PRESERVE_INPUT not supported in this case.
+        copy = shared_array< fftw_complex >( new fftw_complex[ inSize ] );
+        memcpy( copy.get(), source, inSize * sizeof( fftw_complex ) );
+        plan = fftw_plan_dft_c2r( rank, n.get(), (fftw_complex *)copy.get(),
+                                  (double *)dest, FFTW_ESTIMATE );
+        rbRetType = rb_const_get( mModule, rb_intern( "DFLOAT" ) );
+      };
+      rbDest = Data_Wrap_Struct( rb_const_get( mModule, rb_intern( "Malloc" ) ), 0, xfree,
+                                 (void *)dest );
+      rb_ivar_set( rbDest, rb_intern( "@size" ), INT2NUM( size * retTypeSize ) );
+      ERRORMACRO( plan != NULL, Error, , "Error creating FFTW plan" );
+      fftw_execute( plan );
+      fftw_destroy_plan( plan );
+    } else {
+      ERRORMACRO( false, Error, ,
+                  "This datatype is not supported for the selected transform" );
+    };
+    rbRetVal = rb_funcall2( rb_funcall( rb_const_get( mModule, rb_intern( "Sequence" ) ),
+                                        rb_intern( "import" ), 3,
+                                        rbRetType, rbDest, INT2NUM( size ) ),
+                            rb_intern( "reshape" ), rank, RARRAY_PTR(rbShape) );
+  } catch ( std::exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbRetVal;
+}
+