gsl4r 0.0.2 → 0.0.3

data/INSTALL

@@ -11,12 +11,7 @@ System wide gem install using rake
 
   sudo rake install
 
-
-You must also update your environment so that GSL4r can find the gsl shared library, under Mac OS X, and using macports, this is something along the lines of:
-
-export LD_LIBRARY_PATH=/opt/local/lib:$LD_LIBRARY_PATH
-
-Under linux, it might look something like,
-
-export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
+GSL4r uses gsl-config to dynamically determine the location
+of the gsl libraries.  You must have gsl-config in your
+execution path for GSL4r to operate.
 

data/README

@@ -11,7 +11,7 @@ This avoids the complications with implementation specific C extensions or Java
 
 == Documentation
 
-This project is currently in its alpha stages and as of 01 Mar 2010, I have only pushed a library for using Complex functions in GSL, all constants are defined, and some functions for handling blocks and vectors containing blocks.
+This project is currently in its alpha stages and as of 22 Mar 2010, I have only pushed a library for using Complex functions in GSL, all constants are defined, and handling pointers to blocks and vectors and basic vector functions.
 
 == Getting Started
 
@@ -25,10 +25,12 @@ gem install -r gsl4r
 
 == Examples
 
+Also see the examples directory in the gem.
+
 cd gsl4r/lib
 irb -r rubygems -r gsl4r -r gsl4r/complex
 irb(main):001:0> include GSL4r::Complex
-	  => Object
+=> Object
 irb(main):004:0> a=GSL_Complex.create(1,1)
 => (1.0,1.0)
 irb(main):005:0> b=GSL_Complex.create(2,2)
@@ -53,7 +55,22 @@ irb(main):013:0> p CGS::JOULE
 10000000.0
 irb(main):014:0> p MKS::ERG
 1.0e-07
-
+...
+irb -r rubygems -r gsl4r -r gsl4r/vector
+irb(main):001:0> include GSL4r::Vector
+=> Object
+irb(main):002:0> a=GSL_Vector.create(3)
+=> #<GSL4r::Vector::GSL_Vector:0x5ea038>
+irb(main):003:0> b=GSL_Vector.create(3)
+=> #<GSL4r::Vector::GSL_Vector:0x5e66f4>
+irb(main):004:0> a.set_with_array([1,2,3])
+=> #<FFI::Pointer address=0x2db2e0>
+irb(main):005:0> b.set_with_array([4,5,6])
+=> #<FFI::Pointer address=0x4f8260>
+irb(main):006:0> a.mul(b)
+=> 0
+irb(main):012:0> a.values
+=> [4.0, 10.0, 18.0]
 ...
 
 == Questions and/or Comments

data/Rakefile

@@ -63,12 +63,18 @@ task :test => [:gsl_config] do
 
   require 'gsl4r'
   require 'gsl4r/complex'
+  require 'gsl4r/vector'
 
   complextests = GSL4r::Complex::Harness.new
   complextests.write_c_tests
   complextests.compile_c_tests
   complextests.run_c_tests "complex_test.rb"
 
+  vectortests = GSL4r::Vector::Harness.new
+  vectortests.write_c_tests
+  vectortests.compile_c_tests
+  vectortests.run_c_tests "vector_test.rb"
+
   runner = Test::Unit::AutoRunner.new(true)
   runner.to_run << 'test'
   runner.pattern = [/_test.rb$/]

data/changelog

@@ -1,10 +1,12 @@
 0.0.2
 
+* Uses gsl-config at runtime
 * Added all GSL constants
 * Block and Vector memory handling
 * Moved method_missing definition into generic AutoPrefix
 *  class, so that this code is not duplicated amongst many
 *  classes.
+* Added tools in bin/ for generating wrapper stubs and constants
 
 0.0.1
 

data/lib/b_t.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'gsl4r'
+require 'gsl4r/block'
+include FFI
+op1 = MemoryPointer.new :pointer
+op1 = GSL4r::Block::Methods::gsl_block_alloc(50)
+puts op1.get_ulong(0)
+ob1=GSL4r::Block::GSL_Block.new(op1)
+ob2=GSL4r::Block::GSL_Block_Cast.new(op1)
+#puts ob1.length
+#op1.put_array_of_double(1, (1..50).to_a.collect { |i| i=i*5.0 } )
+#ob1[:data].put_array_of_double(0, (1..50).to_a.collect { |i| i=i*5.0 } )
+puts ob2.set( (1..50).to_a.collect { |i| i=i*5.0 } )
+v = ob2.values
+v[1] = 3000.0
+puts v

data/lib/gsl4r.rb

@@ -10,7 +10,7 @@ require 'rubygems'
 require 'ffi'
 
 module GSL4r
-  Version = '0.0.1';
+  Version = '0.0.3';
   GSL_LIB_PATH = File.join([`gsl-config --prefix`.chomp,
 			   "lib","libgsl.#{FFI::Platform::LIBSUFFIX}"])
   GSLCBLAS_LIB_PATH = File.join([`gsl-config --prefix`.chomp,

data/lib/gsl4r/block.rb

@@ -19,29 +19,71 @@ module GSL4r
 
     extend ::FFI::Library
 
-    class GSL_Block < FFI::Struct
-      layout :size, :size_t,
-	:data, :pointer
-
-	def get_size( a_block )
-	  return a_block.get_ulong(0)
+    # lifted from
+    # http://wiki.github.com/ffi/ffi/examples
+    module BlockLayout
+      def self.included(base)
+	base.class_eval do
+	  layout :size, :size_t,
+	    :data, :pointer
 	end
+      end
+    end
 
-	def get_data( a_block )
-	  return a_block.get_array_of_double(1,get_size(a_block))
-	end
+    def get_block_size( a_block )
+      return a_block.get_ulong(0)
+    end
+    module_function :get_block_size
 
-	def set_data( a_block, some_data )
-	  if ( some_data.length >= get_size(a_block) )
-	    raise "data exceeds size of block"
-	  end
-	  a_block.put_array_of_double(1,some_data)
-	end
+    def get_block_data( a_block )
+      return a_block.get_array_of_double(0,get_block_size(a_block))
+    end
+    module_function :get_block_data
+
+    def set_block_data( a_block, some_data )
+      if ( some_data.length > get_block_size(a_block) )
+	raise "data exceeds size of block"
+      end
+      a_block.put_array_of_double(1,some_data)
+      return some_data
+    end
+    module_function :set_block_data
+
+    class GSL_Block < FFI::ManagedStruct
+      include ::GSL4r::Block::BlockLayout
+
+      def self.release(ptr)
+	::GSL4r::Block::Methods::gsl_block_free(ptr)
+      end
 
-      include ::GSL4r::Util::AutoPrefix
+      def length
+	return self[:size]
+      end
 
-      GSL_PREFIX = "gsl_block_"
-      GSL_MODULE = ::GSL4r::Block
+      def values
+	return self[:data].get_array_of_double(0,length)
+      end
+
+      def set( a )
+	self[:data].put_array_of_double(0,a)
+      end
+
+    end
+
+    class GSL_Block_Cast < FFI::Struct
+      include ::GSL4r::Block::BlockLayout
+
+      def length
+	return self[:size]
+      end
+
+      def values
+	return self[:data].get_array_of_double(0,length)
+      end
+
+      def set( a )
+	self[:data].put_array_of_double(0,a)
+      end
 
     end # class GSL_Block
 
@@ -51,9 +93,10 @@ module GSL4r
 
       ffi_lib ::GSL4r::GSL_LIB_PATH
 
-      attach_gsl_function :gsl_block_alloc, [:size_t], :pointer, [:size_t], :pointer, false
-      attach_gsl_function :gsl_block_calloc, [:size_t], :pointer, [:size_t], :pointer, false
-      attach_gsl_function :gsl_block_free, [:pointer], :void, [:pointer], :void, false
+      attach_function :gsl_block_alloc, [:size_t], :pointer
+      attach_function :gsl_block_calloc, [:size_t], :pointer
+      attach_function :gsl_block_free, [:pointer], :void
+
     end
   end # module Block
 end # module GSL4r

data/lib/gsl4r/complex.rb

@@ -72,6 +72,10 @@ module GSL4r
 	  "GSL_Complex"
 	end
 
+	def r_initializer()
+	  r_type + ".create"
+	end
+
 	def r_equals(v1,v2)
 	  "#{v1.to_s}.equals(#{v2.to_s})"
 	end
@@ -104,6 +108,22 @@ module GSL4r
 	end
       end
 
+      def +(other)
+	self.add(other)
+      end
+
+      def -(other)
+	self.sub(other)
+      end
+
+      def *(other)
+	self.mul(other)
+      end
+
+      def /(other)
+	self.div(other)
+      end
+
       # Play nice and have these methods show up in case someone
       # is digging around for them using these reflection routines
       # Note: this won't show the shortened named forms that

data/lib/gsl4r/harness.rb

@@ -44,8 +44,8 @@ module GSL4r
     end
 
     def compile_c_tests
-      compile_s = "#{@c_compiler} #{@c_flags.join(" ")} " +
-	"-o #{TEST_DIR}/#{@c_binary} #{TEST_DIR}/#{@c_src_name}"
+      compile_s = "#{@c_compiler} -o #{TEST_DIR}/#{@c_binary} " +
+       "#{TEST_DIR}/#{@c_src_name} #{@c_flags.join(" ")} "
       p compile_s
       `#{compile_s}`
     end

data/lib/gsl4r/util.rb

@@ -14,8 +14,10 @@ module GSL4r
 
     $c_var_num = 0
 
+    # TODO: The automated test writing is kindof klunky and probably
+    # ought to be re-thought out...
     def attach_gsl_function( method_name, args, return_var, args_type=nil, return_type=nil,
-			    add_self=true )
+			    add_self=true, answerat=0 )
 
       # This function is attached to the extended ::FFI::Library
       # module from the calling namespace, e.g. ::GSL4r::Complex::Methods
@@ -31,32 +33,53 @@ module GSL4r
         # prepare c and ruby args code
 	c_src = ""
 	c_call_vars = []
-	c_return_name = "c_r#{$c_var_num}"
+
+	c_return_name = ( answerat == 0 ? "c_r#{$c_var_num}" : "" )
+
 	r_src = []
 	if ( ! args_type.is_a?(Array) )
 	  args_type = Array.new([args_type])
 	end
         args_type.each { |a_t|
 	  c_var_name = "v#{$c_var_num += 1}"
+
+	  # This tracks if the answer to check against is in a variable
+	  # *other than* the return value.  For example:
+	  # sprintf( char *ans, char *format, ... ), the answer is
+	  # in *ans (aka 1).  answerat == 0 is the return value
+	  if ( answerat == $c_var_num )
+	    c_return_name = c_var_name
+	  end
+
 	  c_src << (a_t.respond_to?("c_type") ?
 		    "  #{a_t.c_type} #{c_var_name};\n" : "#{a_t.to_s} #{c_var_name} ")
+	  c_src << (a_t.respond_to?("c_initializer") ?
+		    "  #{a_t.c_initializer("#{c_var_name}")}\n" : "")
 	  c_src << (a_t.respond_to?("c_assignment") ?
 		    "  #{a_t.c_assignment("#{c_var_name}")}\n" : "= (#{a_t.to_s})2.0;\n")
 	  c_call_vars << "#{c_var_name}"
 
-	  r_src << (a_t.respond_to?("r_type") ?
-		    "  #{c_var_name} = #{a_t.r_type}.create" : "")
+	  r_src << (a_t.respond_to?("r_initializer") ?
+		    "  #{c_var_name} = #{a_t.r_initializer}" : "")
 	  r_src << (a_t.respond_to?("r_assignment") ?
 		    "  #{a_t.r_assignment("#{c_var_name}")}" : "  #{c_var_name} = 2.0")
 	} # args_type.each
 
 	# prepare c return type
-	c_src << (return_type.respond_to?("c_type") ?
-		  "  #{return_type.c_type} #{c_return_name};\n" :
-		  "  #{return_type.to_s} #{c_return_name};\n")
+	# if the answer is coming back not from the return value,
+	# then don't bother adding this
+	if ( answerat == 0 )
+	  c_src << (return_type.respond_to?("c_type") ?
+		    "  #{return_type.c_type} #{c_return_name};\n" :
+		    "  #{return_type.to_s} #{c_return_name};\n")
+	  c_src << "  #{c_return_name} = "
+	else
+	  c_src << "  "
+	end
 
 	# prepare c call
-	c_src << "  #{c_return_name} = #{method_name}(#{c_call_vars.join(",")});\n"
+	
+	c_src << "#{method_name}(#{c_call_vars.join(",")});\n"
 	
 	# now generate the ruby code for the unit test
 	c_src << "  puts(" << %Q{\\"def test_#{method_name}()\\"} << ");\n"
@@ -69,24 +92,36 @@ module GSL4r
 
 	r_r1 = "r_r1" # ruby result
 	c_src << "  puts(" << %Q{\\"  #{r_r1} = ::#{self.to_s}::#{method_name}(#{c_call_vars.join(",")})\\"} << ");\n"
-	if ( return_type.respond_to?("c_to_r_assignment") )
-	  r_r2 = "r_r2" # ruby result comparitor
-	  c_src << "  puts(" << %Q{\\"  #{r_r2} = #{return_type.r_type}.new\\"} << ");\n"
-	  c_src << "  #{return_type.c_to_r_assignment(r_r2,c_return_name)}"
-	  c_src << "  printf(" << %Q{\\"  assert r_r1.equals(r_r2)\\\\n\\"} << ");\n"
-	else
-	  c_src << "  printf(" << %Q{\\"  assert_in_delta r_r1, %.15g, EPSILON\\\\n\\"} << ", #{c_return_name});\n"
+	if ( answerat == 0 )
+	  if ( return_type.respond_to?("c_to_r_assignment") )
+	    r_r2 = "r_r2" # ruby result comparitor
+	    c_src << "  puts(" << %Q{\\"  #{r_r2} = #{return_type.r_type}.new\\"} << ");\n"
+	    c_src << "  #{return_type.c_to_r_assignment(r_r2,c_return_name)}"
+	    c_src << "  printf(" << %Q{\\"  assert r_r1.equals(r_r2)\\\\n\\"} << ");\n"
+	  else # return_type.respond_to
+	    # TODO: this will have to be expanded to handle more types..
+	    # A good default fall back is unsigned long though, for size_t or int returns
+	    # but this could lead to submit errors that aren't really errors...
+	    c_src << "  printf(" << %Q{\\"  assert_in_delta r_r1, #{(return_type == :double ? "%.15g" : "%lu")}, EPSILON\\\\n\\"} << ", #{c_return_name});\n"
+	  end
+	else # answerat == 0
+	  c_src << "  printf(" << %Q{\\"  assert }
+	  # I'd rather this fail at run-time so, don't check if r_answer is there
+	  c_src << args_type[answerat-1].r_answer("#{c_call_vars[answerat-1]}")
+	  c_src << args_type[answerat-1].r_equals << %Q{\\");\n}
+	  c_src << "  " << args_type[answerat-1].c_answer("#{c_call_vars[answerat-1]}")
 	end
 
 	c_src << "  puts(" << %Q{\\"end\\"} << ");"
 
 	# TODO, create unit test for aliased/shorthand versions of methods
-
-	eval <<-end_eval
-        def c_test_#{method_name}
-  	  # Build list of arguments and their values
-	  "#{c_src}"
-        end
+ 
+	self.module_eval <<-end_eval
+	  def c_test_#{method_name}
+  	    # Build list of arguments and their values
+	    "#{c_src}"
+          end
+	  module_function :c_test_#{method_name}
 	end_eval
       end
     end # attach_gsl_function

data/lib/gsl4r/vector.rb

@@ -1,7 +1,7 @@
-
 #
 # == Other Info
 #
+#
 # Author::	Colby Gutierrez-Kraybill
 # Version::	$Id$
 #
@@ -9,26 +9,342 @@
 require 'rubygems'
 require 'ffi'
 
+require 'gsl4r/util'
+require 'gsl4r/harness'
+require 'gsl4r/block'
+
 module GSL4r
   module Vector
 
     extend ::FFI::Library
 
-    ffi_lib ::GSL4r::GSL_LIB_PATH
+    # layout/cast/struct pattern /lifted from
+    # http://wiki.github.com/ffi/ffi/examples
+    module VectorLayout
+      def self.included(base)
+	base.class_eval do
+	  layout :size,	:size_t,
+	    :stride,	:size_t,
+	    :data,	:pointer,
+	    :block,	:pointer,
+	    :owner,	:int
+	end
+      end
+    end
+
+    def get_vector_size( a_vector )
+      return a_vector.get_ulong(0)
+    end
+    module_function :get_vector_size
+
+    def get_vector_stride( a_vector )
+      return a_vector.get_ulong(1)
+    end
+    module_function :get_vector_stride
+
+    # TODO fix me
+    def get_vector_data( a_vector )
+      return a_vector.values
+    end
+    module_function :get_vector_data
+
+    def set_vector_data( a_block, some_data )
+      if ( some_data.length > ::GSL4r::Block::get_block_size(a_block) )
+	raise "data exceeds size of block"
+      end
+      a_block.put_array_of_double(1,some_data)
+      return some_data
+    end
+    module_function :set_vector_data
+
+    class GSL_Vector < FFI::ManagedStruct
+      include ::GSL4r::Vector::VectorLayout
 
-    class GSL_Vector < ::FFI::Struct
-      layout :size,	:size_t,
-	:stride,	:size_t,
-	:data,	:pointer,
-	:block,	:pointer,
-	:owner,	:int
+      attr_accessor :vecptr
+
+      GSL_PREFIX = "gsl_vector_"
+      GSL_MODULE = ::GSL4r::Vector
 
       include ::GSL4r::Util::AutoPrefix
-      module ::GSL4r::Util::AutoPrefix
-	GSL_PREFIX = "gsl_vector_"
-	GSL_MODULE = ::GSL4r::Vector
+
+      def self.create( size )
+	@vecptr = ::FFI::MemoryPointer.new :pointer
+	@vecptr = ::GSL4r::Vector::Methods::gsl_vector_alloc( size )
+
+	GSL_Vector.new( @vecptr )
+      end
+
+      def self.release(ptr)
+	::GSL4r::Vector::Methods::gsl_vector_free(ptr)
+      end
+
+      def length
+	return self[:size]
+      end
+
+      def values
+	return self[:data].get_array_of_double(0,self.length)
+      end
+
+      def set_with_array( a )
+	self[:data].put_array_of_double(0,a)
+      end
+
+      def minmax
+	min = ::FFI::MemoryPointer.new :double
+	max = ::FFI::MemoryPointer.new :double
+
+	::GSL4r::Vector::Methods::gsl_vector_minmax( self, min, max )
+
+	rmin = min.get_double(0)
+	rmax = max.get_double(0)
+	min = nil
+	max = nil
+
+	return rmin, rmax
+      end
+
+      def minmax_index
+	min = ::FFI::MemoryPointer.new :size_t
+	max = ::FFI::MemoryPointer.new :size_t
+
+	::GSL4r::Vector::Methods::gsl_vector_minmax_index( self, min, max )
+
+	# TODO: Submit request that get_size_t be added to FFI?
+	if min.size > FFI::type_size( :ulong )
+	  raise RuntimeError, "unsigned long < size_t on this platform!"
+	end
+
+	rmin = min.get_ulong(0)
+	rmax = max.get_ulong(0)
+	min = nil
+	max = nil
+
+	return rmin, rmax
+      end
+
+      # Play nice and have these methods show up in case someone
+      # is digging around for them using these reflection routines
+      # Note: this won't show the shortened named forms that
+      # will automatically be generated when called.
+      def methods
+	a = super
+	a + GSL_MODULE::Methods.methods.grep(/^#{GSL_PREFIX}/)
+      end
+      
+      class << self
+	def r_type()
+	  "GSL_Vector"
+	end
+	def r_initializer()
+	  r_type + ".create(3)"
+	end
+	def r_equals()
+	  " == "
+	end
+	def r_answer( name )
+	  "#{name}.values"
+	end
+	def r_assignment( name )
+	  "#{name}.set( [1.0,2.0,3.0] )" # these numbers should make c_assignment ...
+	end
+	def c_to_r_assignment(v1,v2)
+	  "printf(\\\"  #{v1}.set([%.15g,%.15g,%.15g])\\\\n\\\",gsl_vector_get(#{v2},0),gsl_vector_get(#{v2},1),gsl_vector_get(#{v2},2));\\n"
+	end
+	def c_type()
+	  "gsl_vector *"
+	end
+	def c_assignment( name )
+	  "gsl_vector_set(#{name}, 0, 1.0 ); gsl_vector_set(#{name}, 1, 2.0 ); gsl_vector_set(#{name}, 2, 3.0 );"
+	end
+	def c_answer( name )
+	  "printf(\\\"[%.15g,%.15g,%.15g]\\\\n\\\",gsl_vector_get(#{name},0),gsl_vector_get(#{name},1),gsl_vector_get(#{name},2));\\n"
+	end
+	def c_equals()
+	end
+	def c_initializer( name )
+	  "#{name} = gsl_vector_alloc(3); "
+	end
+      end # class << self
+
+    end # GSL_Vector
+
+    class GSL_Vector_Cast < FFI::Struct
+      include ::GSL4r::Vector::VectorLayout
+
+      GSL_PREFIX = "gsl_vector_"
+      GSL_MODULE = ::GSL4r::Vector
+
+      include ::GSL4r::Util::AutoPrefix
+
+      def length
+	return self[:size]
+      end
+
+      def values
+	return self[:data].get_array_of_double(0,length)
+      end
+
+      def set_with_array( a )
+	self[:data].put_array_of_double(0,a)
+      end
+
+      def minmax
+	min = ::FFI::MemoryPointer.new :double
+	max = ::FFI::MemoryPointer.new :double
+
+	::GSL4r::Vector::Methods::gsl_vector_minmax( self, min, max )
+
+	rmin = min.get_double(0)
+	rmax = max.get_double(0)
+	min = nil
+	max = nil
+
+	return rmin, rmax
+      end
+
+      def minmax_index
+	min = ::FFI::MemoryPointer.new :size_t
+	max = ::FFI::MemoryPointer.new :size_t
+
+	::GSL4r::Vector::Methods::gsl_vector_minmax_index( self, min, max )
+
+	# TODO: Submit request that get_size_t be added to FFI?
+	if min.size > FFI::type_size( :ulong )
+	  raise RuntimeError, "unsigned long < size_t on this platform!"
+	end
+
+	rmin = min.get_ulong(0)
+	rmax = max.get_ulong(0)
+	min = nil
+	max = nil
+
+	return rmin, rmax
+      end
+
+      # Play nice and have these methods show up in case someone
+      # is digging around for them using these reflection routines
+      # Note: this won't show the shortened named forms that
+      # will automatically be generated when called.
+      def methods
+	a = super
+	a + GSL_MODULE::Methods.methods.grep(/^#{GSL_PREFIX}/)
+      end
+      
+    end # class GSL_Vector_Cast
+
+    module Methods
+      extend ::GSL4r::Util
+      extend ::FFI::Library
+
+      ffi_lib ::GSL4r::GSL_LIB_PATH
+
+      # Utility routines related to handling vectors
+      #
+      # Creating vectors
+      attach_function :gsl_vector_alloc, [:size_t], :pointer
+      attach_function :gsl_vector_calloc, [:size_t], :pointer
+      attach_function :gsl_vector_free, [:pointer], :void
+
+      # set/get individual values
+      attach_gsl_function :gsl_vector_get, [:pointer, :size_t], :double
+      attach_gsl_function :gsl_vector_set, [:pointer, :size_t, :double], :void
+
+      # set values across entire vector
+      attach_gsl_function :gsl_vector_set_all, [:pointer, :double], :void
+      attach_gsl_function :gsl_vector_set_zero, [:pointer], :void
+      attach_gsl_function :gsl_vector_set_basis, [:pointer, :size_t], :int
+
+      # Vector views
+      #
+      # These return a GSL_Vector_Cast to avoid inappropriate garbage
+      # collection on the returned structure
+      attach_gsl_function :gsl_vector_subvector, [:pointer, :size_t, :size_t],
+	GSL_Vector_Cast.by_value
+
+      attach_gsl_function :gsl_vector_subvector_with_stride,
+	[:pointer, :size_t, :size_t, :size_t],
+	GSL_Vector_Cast.by_value
+
+      # Copying vectors
+      attach_gsl_function :gsl_vector_memcpy, [:pointer, :pointer], :int
+      attach_gsl_function :gsl_vector_swap, [:pointer, :pointer], :int
+
+      # Exchanging elements
+      attach_gsl_function :gsl_vector_swap_elements, [:pointer, :size_t, :size_t], :int
+      attach_gsl_function :gsl_vector_reverse, [:pointer], :int
+
+      # basic arithmetic
+      # a'i = ai + bi
+      attach_gsl_function :gsl_vector_add, [:pointer, :pointer], :int,
+	[GSL_Vector, GSL_Vector], :double, true, 1
+      # a'i = ai - bi
+      attach_gsl_function :gsl_vector_sub, [:pointer, :pointer], :int,
+	[GSL_Vector, GSL_Vector], :double, true, 1
+      # a'i = ai * bi
+      attach_gsl_function :gsl_vector_mul, [:pointer, :pointer], :int,
+	[GSL_Vector, GSL_Vector], :double, true, 1
+      # a'i = ai / bi
+      attach_gsl_function :gsl_vector_div, [:pointer, :pointer], :int,
+	[GSL_Vector, GSL_Vector], :double, true, 1
+      # a'i = x * ai
+      attach_gsl_function :gsl_vector_scale, [:pointer, :double], :int,
+	[GSL_Vector, :double], :double, true, 1
+      # a'i = x + ai
+      attach_gsl_function :gsl_vector_add_constant, [:pointer, :double], :int,
+	[GSL_Vector, :double], :double, true, 1
+      # return max value
+      attach_gsl_function :gsl_vector_max, [:pointer], :double,
+	[GSL_Vector], :double
+      # return max value index
+      attach_gsl_function :gsl_vector_max_index, [:pointer], :size_t,
+	[GSL_Vector], :size_t
+      # return min value
+      attach_gsl_function :gsl_vector_min, [:pointer], :double,
+	[GSL_Vector], :double
+      # return min value index
+      attach_gsl_function :gsl_vector_min_index, [:pointer], :size_t,
+	[GSL_Vector], :size_t
+
+      # minmax routines have special wrappers to make them easier to use
+      # return min and max values
+      # TODO: increase answer checking sophistication in util to compare
+      # results that arrive in mulitple arguments, like minmax...
+      attach_function :gsl_vector_minmax, [:pointer, :pointer, :pointer], :void
+      attach_function :gsl_vector_minmax_index, [:pointer, :pointer, :pointer], :void
+
+      # Vector properties
+      
+      # returns 1 if vector is null, 0 otherwise
+      attach_gsl_function :gsl_vector_isnull, [:pointer], :int,
+	[GSL_Vector], :int
+      # returns 1 if vector is all positive, 0 otherwise
+      attach_gsl_function :gsl_vector_ispos, [:pointer], :int,
+	[GSL_Vector], :int
+      # returns 1 if vector is all negative, 0 otherwise
+      attach_gsl_function :gsl_vector_isneg, [:pointer], :int,
+	[GSL_Vector], :int
+      # returns 1 if vector is all non-negative, 0 otherwise
+      attach_gsl_function :gsl_vector_isnonneg, [:pointer], :int,
+	[GSL_Vector], :int
+
+    end
+
+    class Harness
+      include ::GSL4r::Harness
+
+      def initialize
+	@c_compiler = "gcc"
+	@c_src_name = "gsl_vector_tests_gen.c"
+	@c_binary = "gsl_vector_tests_gen"
+	@c_includes = ["gsl/gsl_vector.h"]
+	@c_flags = [`gsl-config --libs`.chomp,`gsl-config --cflags`.chomp]
+	@c_tests = ::GSL4r::Vector::Methods.methods.grep(/^c_test/)
+	@r_header = %Q{$: << File.join('..','lib')\\nrequire 'test/unit'\\nrequire 'test/unit/autorunner'\\nrequire 'gsl4r/vector'\\ninclude GSL4r::Vector\\nclass VectorTests < Test::Unit::TestCase\\n  EPSILON = 5.0e-15}
+
+	@r_footer = %Q{end}
       end
+    end
 
-    end # class GSL_Vector
   end # module Vector
 end # module GSL4r