gs2crmod 0.5.2

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+   gem "coderunner", ">= 0.11.0"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "> 1.0.0"
+  gem "jeweler", ">= 1.8.4"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Edmund Highcock
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+gs2crmod
+========
+
+GS2 is a gyrokinetic flux tube initial value turbulence code which can be used for fusion or astrophysical plasmas. CodeRunner is a framework for the automated running and analysis of large simulations. This module allows GS2 (and its sister code AstroGK) to harness the power of the CodeRunner framework.

data/README.rdoc

@@ -0,0 +1,19 @@
+= gs2crmod
+
+Description goes here.
+
+== Contributing to gs2crmod
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Edmund Highcock. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "gs2crmod"
+  gem.homepage = "http://gs2crmod.sourceforge.net"
+  gem.license = "GSLv3"
+  gem.summary = %Q{Module to allow CodeRunner to run and analyse the GS2 and AstroGK codes.}
+  gem.description = %Q{GS2 is a gyrokinetic flux tube initial value turbulence code which can be used for fusion or astrophysical plasmas. CodeRunner is a framework for the automated running and analysis of large simulations. This module allows GS2 (and its sister code AstroGK) to harness the power of the CodeRunner framework.}
+  gem.email = "edmundhighcock@sourceforge.net"
+  gem.authors = ["Edmund Highcock"]
+	gem.extensions = "ext/extconf.rb"
+	gem.files.include('ext/*.c', 'include/*.h', 'ext/*.rb')
+	gem.required_ruby_version = '>= 1.9.1'
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+#require 'rcov/rcovtask'
+#Rcov::RcovTask.new do |test|
+  #test.libs << 'test'
+  #test.pattern = 'test/**/test_*.rb'
+  #test.verbose = true
+  #test.rcov_opts << '--exclude "gems/*"'
+#end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "gs2crmod #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.2

data/ext/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+$CFLAGS = " -Wall -I../include "
+
+srcs = Dir.glob("*.c")
+                                                                                                         
+$objs = srcs.collect { |f| f.sub(".c", ".o") }                                                           
+                                                                                                         
+create_makefile("gs2crmod_ext")  

data/ext/gs2crmod_ext.c

@@ -0,0 +1,366 @@
+#include "gs2crmod_ext.h"
+
+VALUE gs2crmod_tensor_complexes_field_gsl_tensor_complex_2(VALUE self, VALUE options)
+{
+	VALUE field, field_complex, field_narray;
+	VALUE field_complex_narray;
+	VALUE cgsl_tensor_complex;
+	VALUE ccomplex;
+	VALUE shape;
+	int *c_shape;
+	int i, j, k;
+
+	ccomplex = RGET_CLASS_TOP("Complex");
+	field = RFCALL_11("field_gsl_tensor", options);
+	cgsl_tensor_complex = RGET_CLASS(cgsl, "TensorComplex");
+	shape = rb_funcall(field, rb_intern("shape"), 0);
+	/*rb_p(shape);*/
+
+	CR_INT_ARY_R2C_STACK(shape, c_shape);
+	field_complex = rb_funcall3(cgsl_tensor_complex, rb_intern("alloc"), 3, RARRAY_PTR(shape));
+	field_narray = RFCALL_10_ON(field, "narray");
+	field_complex_narray = RFCALL_10_ON(field_complex, "narray");
+	/*rb_p(field_complex);*/
+	for (i=0;i<c_shape[0];i++)
+	  for (j=0;j<c_shape[1];j++)
+			for (k=0;k<c_shape[2];k++)
+			{
+
+				/*printf("%d %d %d\n", i, j, k);*/
+				VALUE cmplex, re, im;
+				re = rb_funcall(
+								field_narray,
+								rb_intern("[]"),
+								4,
+								INT2FIX(0),
+								INT2FIX(k), INT2FIX(j), INT2FIX(i)
+							); 
+				/*printf("%d %d %d re\n", i, j, k);*/
+				im = rb_funcall(
+								field_narray,
+								rb_intern("[]"),
+								4,
+								INT2FIX(1),
+								INT2FIX(k), INT2FIX(j), INT2FIX(i)
+							);
+				/*printf("%d %d %d im\n", i, j, k);*/
+				cmplex = 
+					 	rb_funcall(
+							ccomplex,
+							rb_intern("rectangular"),
+							2, re, im
+						);
+				/*printf("%d %d %d again\n", i, j, k);*/
+				rb_funcall(
+						field_complex_narray, 
+						rb_intern("[]="), 
+						4, 
+						INT2FIX(k), INT2FIX(j), INT2FIX(i),
+						cmplex
+					);
+
+			}
+	/*rb_p(field);*/
+
+
+
+		/*field_complex = */
+	return field_complex;
+}
+
+VALUE gs2crmod_tensor_field_gsl_tensor(VALUE self, VALUE options)
+{
+	VALUE cgsl_tensor;
+	VALUE field, field_narray;
+	VALUE field_real_space, field_real_space_narray;
+	VALUE field_real_space_new, field_real_space_new_narray;
+	VALUE shape, shape_real_space, shape_real_space_new;
+	VALUE workspacex, workspacey;
+	VALUE ccomplex, cgsl_complex;
+	VALUE re, im, cmplex;
+	VALUE *ary_ptr;
+	VALUE range_x, range_y;
+	int shape0;
+	double* c_field, *c_field_real_space;
+	int* c_shape, *c_shape_real_space;
+	int * c_shape_real_space_new;
+	int i,j,k,m;
+	int kint,km,kold;
+	double frac, interp_value;
+
+	ccomplex = RGET_CLASS_TOP("Complex");
+	cgsl_complex = RGET_CLASS(cgsl, "Complex");
+	cgsl_tensor = RGET_CLASS(cgsl, "Tensor");
+	/*cgsl_vector = RGET_CLASS(cgsl, "Vector");*/
+
+	field = RFCALL_11("field_gsl_tensor", options);
+	field_narray = RFCALL_10_ON(field, "narray");
+	shape = RFCALL_10_ON(field, "shape");
+
+
+	workspacex = RFCALL_11_ON(cgsl_vector_complex, "alloc", RARRAY_PTR(shape)[1]);
+	shape0 = NUM2INT(RARRAY_PTR(shape)[0]);
+	workspacey = RFCALL_11_ON(cgsl_vector, "alloc", INT2NUM(shape0 * 2 - 2 + shape0%2));
+
+	field_real_space = rb_funcall(
+			cgsl_tensor,
+			rb_intern("alloc"),
+			3,
+			RFCALL_10_ON(workspacey, "size"),
+			RARRAY_PTR(shape)[1],
+			RARRAY_PTR(shape)[2]
+			);
+	field_real_space_narray = RFCALL_10_ON(field_real_space, "narray");
+	shape_real_space = RFCALL_10_ON(field_real_space, "shape");
+	
+	CR_INT_ARY_R2C_STACK(shape, c_shape);
+	CR_INT_ARY_R2C_STACK(RFCALL_10_ON(field_real_space, "shape"), c_shape_real_space);
+
+	c_field = ALLOC_N(double, c_shape[0] * c_shape[1] * c_shape[2] * c_shape[3]);
+
+	/*printf("Allocated stuff\n");*/
+	for (j=0; j<c_shape[2]; j++) /*theta loop*/
+	{
+		for (i=0; i<c_shape[0]; i++) /*ky loop*/
+		{
+			for (k=0; k<c_shape[1]; k++) /*ky loop*/
+			{
+				/*First copy the field onto the 
+				 * x workspace, Fourier transform
+				 * the workspace and copy it onto
+				 * the c array*/
+				re = rb_funcall(
+								field_narray,
+								rb_intern("[]"),
+								4,
+								INT2FIX(0),
+								INT2FIX(j), INT2FIX(k), INT2FIX(i)
+							); 
+				/*printf("%d %d %d re\n", i, j, k);*/
+				im = rb_funcall(
+								field_narray,
+								rb_intern("[]"),
+								4,
+								INT2FIX(1),
+								INT2FIX(j), INT2FIX(k), INT2FIX(i)
+							);
+				/*printf("%d %d %d im\n", i, j, k);*/
+				cmplex = 
+					 	rb_funcall(
+							cgsl_complex,
+							rb_intern("alloc"),
+							2, re, im
+						);
+				/*printf("%d %d %d again\n", i, j, k);*/
+				/*printf("Made complex\n");*/
+				rb_funcall(
+					workspacex,
+					rb_intern("[]="),
+					2,
+					INT2FIX(k),
+					cmplex);
+				/*printf("Added complex\n");*/
+
+			}
+			/*printf("Made complex vector\n");*/
+			workspacex = RFCALL_10_ON(workspacex, "backward");
+			/*printf("Done x transform\n");*/
+			for (k=0;k<c_shape[1];k++){
+				cmplex = RFCALL_11_ON(workspacex,"[]",INT2FIX(k));
+				c_field[
+					j*c_shape[0]*c_shape[1]*2 +
+					i*c_shape[1]*2 +
+					k*2 
+					] = NUM2DBL(RFCALL_10_ON(cmplex,"real"));
+				c_field[
+					j*c_shape[0]*c_shape[1]*2 +
+					i*c_shape[1]*2 +
+					k*2 + 1
+					] = NUM2DBL(RFCALL_10_ON(cmplex,"imag"));
+
+			}
+		}
+		/*printf("Done x\n");*/
+		/* Now copy onto the y workspace,
+		 * Fourier transform and copy onto 
+		 * the second c array*/
+		for (k=0;k<c_shape[1];k++)
+		{
+		  m=0;	
+		  for (i=0;i<c_shape[0];i++)
+			{
+				rb_funcall(
+						workspacey,
+						rb_intern("[]="),
+						2,
+						INT2FIX(m),
+						rb_float_new(c_field[
+								j*c_shape[0]*c_shape[1]*2 +
+								i*c_shape[1]*2 +
+								k*2 
+								])
+						);
+				m++;
+				/* We are converting a complex array 
+				 * to a half complex array in
+				 * preparation for transforming 
+				 * it to real space, and so their
+				 * are one or two elements we leave
+				 * unfilled.*/
+				if (i==0 || (c_shape[0]%2==0 && i == c_shape[0]/2 + 1)) continue;
+				rb_funcall(
+						workspacey,
+						rb_intern("[]="),
+						2,
+						INT2FIX(m),
+						rb_float_new(c_field[
+								j*c_shape[0]*c_shape[1]*2 +
+								i*c_shape[1]*2 +
+								k*2 + 1
+								])
+						);
+				m++;
+			}
+			/*printf("Made y vector\n");*/
+			/*rb_p(workspacey);*/
+			/*rb_p(RFCALL_10_ON(workspacey, "class"));*/
+				workspacey = RFCALL_10_ON(workspacey, "backward");
+				/*printf("Done y transform\n");*/
+			for (i=0;i<FIX2INT(RFCALL_10_ON(workspacey, "size"));i++)
+			{
+				rb_funcall(
+						field_real_space_narray,
+						rb_intern("[]="), 4,
+						INT2FIX(j), INT2FIX(k), INT2FIX(i),
+						RFCALL_11_ON(workspacey, "[]", INT2FIX(i))
+						);
+			}
+		}
+	}
+	/*printf("HERE!\n");*/
+  range_x = CR_RANGE_INC(
+				(RTEST(CR_HKS(options, "ymin")) ?
+					FIX2INT(CR_HKS(options, "ymin")) :
+			 		0),
+				(RTEST(CR_HKS(options, "ymax")) ?
+					FIX2INT(CR_HKS(options, "ymax")) :
+					c_shape_real_space[0]-1)
+				);
+	/*rb_p(range_x);*/
+	range_y = CR_RANGE_INC(
+				(RTEST(CR_HKS(options, "xmin")) ?
+					FIX2INT(CR_HKS(options, "xmin")) :
+			 		0),
+				(RTEST(CR_HKS(options, "xmax")) ?
+					FIX2INT(CR_HKS(options, "xmax")) :
+					c_shape_real_space[1]-1)
+				);
+	/*printf("Made ranges\n");*/
+	/*rb_p(rb_funcall(field_real_space, rb_intern("[]"), 3, INT2FIX(0), INT2FIX(2), INT2FIX(3)));*/
+	field_real_space = rb_funcall(
+			field_real_space,
+			rb_intern("[]"), 3,
+			range_x,
+			range_y,
+			Qtrue);
+	/*rb_p(rb_funcall(field_real_space, rb_intern("[]"), 3, INT2FIX(0), INT2FIX(2), INT2FIX(3)));*/
+	/*printf("SHORTENED!\n");*/
+	if (RTEST(CR_HKS(options, "interpolate_theta")))
+	{
+		shape_real_space_new = RFCALL_10_ON(shape_real_space, "dup");
+		kint = NUM2INT(CR_HKS(options, "interpolate_theta"));
+		rb_funcall(
+				shape_real_space_new,
+				rb_intern("[]="), 2, INT2FIX(-1),
+				INT2FIX((c_shape_real_space[2] - 1)*kint+1)
+				);
+		CR_INT_ARY_R2C_STACK(shape_real_space_new, c_shape_real_space_new); 
+		ary_ptr = RARRAY_PTR(shape_real_space_new);
+		field_real_space_new = rb_funcall(
+				cgsl_tensor,
+				rb_intern("float"),
+				3,
+				ary_ptr[0], ary_ptr[1], ary_ptr[2]);
+		field_real_space_new_narray = RFCALL_10_ON(field_real_space_new, "narray");
+		/*printf("Allocated");*/
+		/*rb_p(shape_real_space_new);*/
+		for (i=0;i<c_shape_real_space_new[0];i++)
+		for (j=0;j<c_shape_real_space_new[1];j++)
+		{
+			/*printf("i %d j %d k %d\n", i, j, c_shape_real_space_new[2]-1); */
+			rb_funcall(
+					field_real_space_new_narray,
+					rb_intern("[]="),
+					4,INT2FIX(c_shape_real_space_new[2]-1),
+					INT2FIX(j),INT2FIX(i),
+					rb_funcall(
+						field_real_space_narray,
+						rb_intern("[]"), 3,
+						INT2FIX(c_shape_real_space[2]-1),
+						INT2FIX(j),INT2FIX(i)
+						)
+					);
+			for (k=0;k<c_shape_real_space_new[2]-1;k++)
+			{
+				/*printf("i %d j %d k %d\n", i, j, k); */
+				km = k%kint;
+				frac = (double)km/(double)kint;
+				kold = (k-km)/kint;
+				interp_value = NUM2DBL(
+						rb_funcall(
+							field_real_space_narray,
+							rb_intern("[]"),3,
+							INT2FIX(kold),INT2FIX(j),INT2FIX(i)
+							)
+						)*(1.0-frac) + NUM2DBL(
+						rb_funcall(
+							field_real_space_narray,
+							rb_intern("[]"),3,
+							INT2FIX(kold+1),INT2FIX(j),INT2FIX(i)
+							)
+						) * frac;
+				rb_funcall(
+						field_real_space_new_narray,
+						rb_intern("[]="), 4,
+						INT2FIX(k),INT2FIX(j),INT2FIX(i),
+						rb_float_new(interp_value)
+						);
+				/*if (i==0 && j==2 && k==3){*/
+					/*printf("frac %f\n", frac);*/
+				/*}*/
+			}
+		}
+
+		field_real_space = field_real_space_new;
+	}
+	/*rb_p(shape_real_space_new);*/
+	return field_real_space;
+}
+
+void Init_gs2crmod_ext()
+{
+	/*printf("HERE!!!");*/
+	ccode_runner =  RGET_CLASS_TOP("CodeRunner");
+	ccode_runner_gs2 =  rb_define_class_under(ccode_runner, "Gs2",
+			RGET_CLASS(
+				RGET_CLASS(ccode_runner, "Run"), 
+				"FortranNamelist"
+				)
+			);
+
+	ccode_runner_gs2_gsl_tensor_complexes = rb_define_module_under(ccode_runner_gs2, "GSLComplexTensors");
+	rb_include_module(ccode_runner_gs2, ccode_runner_gs2_gsl_tensor_complexes);
+
+	ccode_runner_gs2_gsl_tensors = rb_define_module_under(ccode_runner_gs2, "GSLTensors"); 
+	rb_include_module(ccode_runner_gs2, ccode_runner_gs2_gsl_tensors);
+
+	cgsl = RGET_CLASS_TOP("GSL");
+	cgsl_vector = RGET_CLASS(cgsl, "Vector");
+	cgsl_vector_complex = RGET_CLASS(cgsl_vector, "Complex");
+
+	rb_define_method(ccode_runner_gs2_gsl_tensor_complexes, "field_gsl_tensor_complex_2", gs2crmod_tensor_complexes_field_gsl_tensor_complex_2, 1);
+	rb_define_method(ccode_runner_gs2_gsl_tensors, "field_real_space_gsl_tensor", gs2crmod_tensor_field_gsl_tensor, 1);
+
+	/*rb_define_method(ccode_runner_ext, "hello_world", code_runner_ext_hello_world, 0);*/
+}
+

data/gs2crmod.gemspec

@@ -0,0 +1,98 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "gs2crmod"
+  s.version = "0.5.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Edmund Highcock"]
+  s.date = "2012-10-10"
+  s.description = "GS2 is a gyrokinetic flux tube initial value turbulence code which can be used for fusion or astrophysical plasmas. CodeRunner is a framework for the automated running and analysis of large simulations. This module allows GS2 (and its sister code AstroGK) to harness the power of the CodeRunner framework."
+  s.email = "edmundhighcock@sourceforge.net"
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "ext/extconf.rb",
+    "ext/gs2crmod_ext.c",
+    "gs2crmod.gemspec",
+    "include/gs2crmod_ext.h",
+    "lib/gs2crmod.rb",
+    "lib/gs2crmod/astrogk.rb",
+    "lib/gs2crmod/astrogk/astrogk.rb",
+    "lib/gs2crmod/astrogk/calculations.rb",
+    "lib/gs2crmod/astrogk/check_convergence.rb",
+    "lib/gs2crmod/astrogk/deleted_variables.rb",
+    "lib/gs2crmod/astrogk/graphs.rb",
+    "lib/gs2crmod/astrogk/gsl_data.rb",
+    "lib/gs2crmod/astrogk/gsl_tools.rb",
+    "lib/gs2crmod/astrogk/ingen.rb",
+    "lib/gs2crmod/astrogk/input_file_tools.rb",
+    "lib/gs2crmod/astrogk/namelist_tools.rb",
+    "lib/gs2crmod/astrogk/namelists.rb",
+    "lib/gs2crmod/astrogk/properties.rb",
+    "lib/gs2crmod/astrogk/species_dependent_namelists.rb",
+    "lib/gs2crmod/astrogk/test_gs2.rb",
+    "lib/gs2crmod/calculations.rb",
+    "lib/gs2crmod/check_convergence.rb",
+    "lib/gs2crmod/deleted_variables.rb",
+    "lib/gs2crmod/graphs.rb",
+    "lib/gs2crmod/graphs_rdoc.rb",
+    "lib/gs2crmod/gs2.rb",
+    "lib/gs2crmod/gsl_data.rb",
+    "lib/gs2crmod/gsl_data_3d.rb",
+    "lib/gs2crmod/gsl_tools.rb",
+    "lib/gs2crmod/ingen.rb",
+    "lib/gs2crmod/namelists.rb",
+    "lib/gs2crmod/properties.rb",
+    "lib/gs2crmod/species_dependent_namelists.rb",
+    "lib/gs2crmod/test_gs2.rb",
+    "lib/gs2crmod_extension.rb",
+    "test/helper.rb",
+    "test/test_gs2crmod.rb"
+  ]
+  s.homepage = "http://gs2crmod.sourceforge.net"
+  s.licenses = ["GSLv3"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.1")
+  s.rubygems_version = "1.8.24"
+  s.summary = "Module to allow CodeRunner to run and analyse the GS2 and AstroGK codes."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<coderunner>, [">= 0.11.0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.8.4"])
+    else
+      s.add_dependency(%q<coderunner>, [">= 0.11.0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["> 1.0.0"])
+      s.add_dependency(%q<jeweler>, [">= 1.8.4"])
+    end
+  else
+    s.add_dependency(%q<coderunner>, [">= 0.11.0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["> 1.0.0"])
+    s.add_dependency(%q<jeweler>, [">= 1.8.4"])
+  end
+end
+

data/include/gs2crmod_ext.h

@@ -0,0 +1,58 @@
+#include "ruby.h"
+
+
+#define RGET_CLASS(class_over, x) (rb_const_get(class_over, rb_intern(x)))
+#define RGET_CLASS_TOP(x) (RGET_CLASS(rb_cObject, x))
+#define RFCALL_10(name) (rb_funcall(self, rb_intern(name), 0))
+#define RFCALL_10_ON(obj, name) (rb_funcall(obj, rb_intern(name), 0))
+#define RFCALL_11(name, arg1) (rb_funcall(self, rb_intern(name), 1, arg1))
+#define RFCALL_11_ON(obj, name, arg1) (rb_funcall(obj, rb_intern(name), 1, arg1))
+#define CR_ELEMENT_ACCESS(recvr, key) ( \
+		RFCALL_11_ON(recvr, "[]", key) \
+		)
+#define CR_HKS(hash, cstr) (CR_ELEMENT_ACCESS(hash, ID2SYM(rb_intern(cstr))))
+#define CR_RANGE_INC(start, end) (rb_funcall(RGET_CLASS_TOP("Range"), rb_intern("new"), 2, INT2FIX(start), INT2FIX(end)))
+#define CR_RANGE_EXC(start, end) (rb_funcall(RGET_CLASS_TOP("Range"), rb_intern("new"), 3, INT2FIX(start), INT2FIX(end), Qtrue))
+
+/*Allocates an integer array on the heap
+ with values of array. int_ptr should be
+ an unallocated int*. array should not
+ contain anything except ints.  */
+#define CR_INT_ARY_R2C_STACK( array,int_ptr)\
+ { int cr_internal_xaa12; \
+	cr_internal_xaa12 = RARRAY_LEN(array);	\
+	int_ptr =	ALLOCA_N(int, cr_internal_xaa12);\
+	int cr_internal_xaa11;\
+ 	for (cr_internal_xaa11=0;\
+		cr_internal_xaa11< cr_internal_xaa12;\
+		cr_internal_xaa11++)\
+			int_ptr[cr_internal_xaa11] = \
+			FIX2INT(RARRAY_PTR(array)[cr_internal_xaa11]);\
+		}
+
+
+/*Allocates an integer array on the heap
+ with values of array. int_ptr should be
+ an unallocated int*. array should not
+ contain anything except ints; this is 
+ checked in this macro. */
+#define CR_INT_ARY_R2C_STACK_TCHECK( array,int_ptr)\
+ { int cr_internal_xaa12; \
+	cr_internal_xaa12 = RARRAY_LEN(array);	\
+	int_ptr =	ALLOCA_N(int, cr_internal_xaa12);\
+	int cr_internal_xaa11;\
+ 	for (cr_internal_xaa11=0;\
+		cr_internal_xaa11< cr_internal_xaa12;\
+		cr_internal_xaa11++)\
+			int_ptr[cr_internal_xaa11] = \
+			NUM2INT(RARRAY_PTR(array)[cr_internal_xaa11]);\
+		}
+					
+
+static VALUE cgsl; 
+static VALUE ccode_runner; 
+static VALUE ccode_runner_gs2; 
+static VALUE ccode_runner_gs2_gsl_tensor_complexes; 
+static VALUE ccode_runner_gs2_gsl_tensors; 
+static VALUE cgsl_vector, cgsl_vector_complex;
+/*void Init_code_runner_ext();*/