gsl 1.12.108

data/ext/error.c

@@ -0,0 +1,194 @@
+/*
+  error.c
+  Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
+    (C) Copyright 2001-2006 by Yoshiki Tsunesada
+
+  Ruby/GSL is free software: you can redistribute it and/or modify it
+  under the terms of the GNU General Public License.
+  This library is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY.
+*/
+#include "rb_gsl.h"
+#include <gsl/gsl_errno.h>
+#include "rb_gsl_array.h"
+#include "rb_gsl_common.h"
+#include "rb_gsl_function.h"
+
+static VALUE eHandler;
+static VALUE cgsl_error[35];
+static VALUE *pgsl_error;
+
+static void Init_rb_gsl_define_GSL_CONST(VALUE module);
+void rb_gsl_error_handler(const char *reason, const char *file,
+			  int line, int gsl_errno);
+static void rb_gsl_my_error_handler(const char *reason, const char *file,
+				    int line, int gsl_errno);
+
+void rb_gsl_error_handler(const char *reason, const char *file,
+			  int line, int gsl_errno)
+{
+  const char *emessage = gsl_strerror(gsl_errno);
+  rb_raise(pgsl_error[gsl_errno], 
+	   "Ruby/GSL error code %d, %s (file %s, line %d), %s",
+	   gsl_errno, reason, file, line, emessage);
+}
+
+static void rb_gsl_my_error_handler(const char *reason, const char *file,
+				    int line, int gsl_errno)
+{
+  VALUE vreason, vfile;
+  VALUE vline, verrno;
+  VALUE result;
+  vreason = rb_str_new2(reason);
+  vfile = rb_str_new2(file);
+  vline = INT2FIX(line);
+  verrno = INT2FIX(gsl_errno);
+  result = rb_funcall(eHandler, RBGSL_ID_call, 4, vreason, vfile, vline, verrno);
+}
+
+static VALUE rb_gsl_set_error_handler(int argc, VALUE *argv, VALUE module)
+{
+  if (rb_block_given_p()) {
+    eHandler = RB_GSL_MAKE_PROC;
+    gsl_set_error_handler(&rb_gsl_my_error_handler);
+    return Qtrue;
+  }
+  switch (argc) {
+  case 0:
+    gsl_set_error_handler(&rb_gsl_error_handler);
+    return Qtrue;
+    break;
+  case 1:
+    CHECK_PROC(argv[0]);
+    eHandler = argv[0];
+    gsl_set_error_handler(&rb_gsl_my_error_handler);
+    return Qtrue;
+    break;
+  default:
+    rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1 Proc)", argc);
+    break;
+  }
+}
+
+static VALUE rb_gsl_set_default_error_handler(VALUE module)
+{
+  gsl_set_error_handler(&rb_gsl_error_handler);
+  return Qtrue;
+}
+
+static void rb_gsl_define_exceptions(VALUE module)
+{
+  VALUE mgsl_error;
+  mgsl_error = rb_define_module_under(module, "ERROR");
+  pgsl_error = &cgsl_error[2];
+  pgsl_error[-2] = rb_define_class_under(mgsl_error, "CONTINUE", rb_cFixnum);
+  pgsl_error[-1] = rb_define_class_under(mgsl_error, "FAILURE", rb_eRuntimeError);
+  pgsl_error[0] = rb_define_class_under(mgsl_error, "SUCCESS", rb_cFixnum);
+  pgsl_error[1] = rb_define_class_under(mgsl_error, "EDOM", rb_eRangeError);
+  pgsl_error[2] = rb_define_class_under(mgsl_error, "ERANGE", rb_eRangeError);
+  pgsl_error[3] = rb_define_class_under(mgsl_error, "EFAULT", rb_eRuntimeError);
+  pgsl_error[4] = rb_define_class_under(mgsl_error, "EINVAL", rb_eIndexError);
+  pgsl_error[5] = rb_define_class_under(mgsl_error, "EFAILED", rb_eRuntimeError);
+  pgsl_error[6] = rb_define_class_under(mgsl_error, "EFACTOR", rb_eRuntimeError);
+  pgsl_error[7] = rb_define_class_under(mgsl_error, "ESANITY", rb_eRuntimeError);
+  pgsl_error[8] = rb_define_class_under(mgsl_error, "ENOMEM", rb_eNoMemError);
+  pgsl_error[9] = rb_define_class_under(mgsl_error, "EBADFUNC", rb_eRuntimeError);
+  pgsl_error[10] = rb_define_class_under(mgsl_error, "ERUNAWAY", rb_eRuntimeError);
+  pgsl_error[11] = rb_define_class_under(mgsl_error, "EMAXITER", rb_eRuntimeError);
+  pgsl_error[12] = rb_define_class_under(mgsl_error, "EZERODIV", rb_eZeroDivError);
+  pgsl_error[13] = rb_define_class_under(mgsl_error, "EBADTOL", rb_eRuntimeError);
+  pgsl_error[14] = rb_define_class_under(mgsl_error, "ETOL", rb_eRuntimeError);
+  pgsl_error[15] = rb_define_class_under(mgsl_error, "EUNDRFLW", rb_eRangeError);
+  pgsl_error[16] = rb_define_class_under(mgsl_error, "EOVRFLW", rb_eRangeError);
+  pgsl_error[17] = rb_define_class_under(mgsl_error, "ELOSS", rb_eRuntimeError);
+  pgsl_error[18] = rb_define_class_under(mgsl_error, "EROUND", rb_eRuntimeError);
+  pgsl_error[19] = rb_define_class_under(mgsl_error, "EBADLEN", rb_eIndexError);
+  pgsl_error[20] = rb_define_class_under(mgsl_error, "ENOTSQR", rb_eRuntimeError);
+  pgsl_error[21] = rb_define_class_under(mgsl_error, "ESING", rb_eRuntimeError);
+  pgsl_error[22] = rb_define_class_under(mgsl_error, "EDIVERGE", rb_eRuntimeError);
+  pgsl_error[23] = rb_define_class_under(mgsl_error, "EUNSUP", rb_eRuntimeError);
+  pgsl_error[24] = rb_define_class_under(mgsl_error, "EUNIMPL", rb_eNotImpError);
+  pgsl_error[25] = rb_define_class_under(mgsl_error, "ECACHE", rb_eRuntimeError);
+  pgsl_error[26] = rb_define_class_under(mgsl_error, "ETABLE", rb_eRuntimeError);
+  pgsl_error[27] = rb_define_class_under(mgsl_error, "ENOPROG", rb_eRuntimeError);
+  pgsl_error[28] = rb_define_class_under(mgsl_error, "ENOPROGJ", rb_eRuntimeError);
+  pgsl_error[29] = rb_define_class_under(mgsl_error, "ETOLF", rb_eRuntimeError);
+  pgsl_error[30] = rb_define_class_under(mgsl_error, "ETOLX", rb_eRuntimeError);
+  pgsl_error[31] = rb_define_class_under(mgsl_error, "ETOLG", rb_eRuntimeError);
+  pgsl_error[32] = rb_define_class_under(mgsl_error, "EOF", rb_eEOFError);
+}
+
+static void Init_rb_gsl_define_GSL_CONST(VALUE module)
+{
+  rb_define_const(module, "SUCCESS", INT2FIX(GSL_SUCCESS));
+  rb_define_const(module, "FAILURE", INT2FIX(GSL_FAILURE));
+  rb_define_const(module, "CONTINUE", INT2FIX(GSL_CONTINUE));
+  rb_define_const(module, "EDOM", INT2FIX(GSL_EDOM));
+  rb_define_const(module, "ERANGE", INT2FIX(GSL_ERANGE));
+  rb_define_const(module, "EFAULT", INT2FIX(GSL_EFAULT));
+  rb_define_const(module, "EINVAL", INT2FIX(GSL_EINVAL));
+  rb_define_const(module, "EFAILED", INT2FIX(GSL_EFAILED));
+  rb_define_const(module, "EFACTOR", INT2FIX(GSL_EFACTOR));
+  rb_define_const(module, "ESANITY", INT2FIX(GSL_ESANITY));
+  rb_define_const(module, "ENOMEM", INT2FIX(GSL_ENOMEM));
+  rb_define_const(module, "EBADFUNC", INT2FIX(GSL_EBADFUNC));
+  rb_define_const(module, "ERUNAWAY", INT2FIX(GSL_ERUNAWAY));
+  rb_define_const(module, "EMAXITER", INT2FIX(GSL_EMAXITER));
+  rb_define_const(module, "EZERODIV", INT2FIX(GSL_EZERODIV));
+  rb_define_const(module, "EBADTOL", INT2FIX(GSL_EBADTOL));
+  rb_define_const(module, "ETOL", INT2FIX(GSL_ETOL));
+  rb_define_const(module, "EUNDRFLW", INT2FIX(GSL_EUNDRFLW));
+  rb_define_const(module, "EOVRFLW", INT2FIX(GSL_EOVRFLW));
+  rb_define_const(module, "ELOSS", INT2FIX(GSL_ELOSS));
+  rb_define_const(module, "EROUND", INT2FIX(GSL_EROUND));
+  rb_define_const(module, "EBADLEN", INT2FIX(GSL_EBADLEN));
+  rb_define_const(module, "ENOTSQR", INT2FIX(GSL_ENOTSQR));
+  rb_define_const(module, "ESING", INT2FIX(GSL_ESING));
+  rb_define_const(module, "EDIVERGE", INT2FIX(GSL_EDIVERGE));
+  rb_define_const(module, "EUNSUP", INT2FIX(GSL_EUNSUP));
+  rb_define_const(module, "EUNIMPL", INT2FIX(GSL_EUNIMPL));
+  rb_define_const(module, "ECACHE", INT2FIX(GSL_ECACHE));
+  rb_define_const(module, "ETABLE", INT2FIX(GSL_ETABLE));
+  rb_define_const(module, "ENOPROG", INT2FIX(GSL_ENOPROG));
+  rb_define_const(module, "ENOPROGJ", INT2FIX(GSL_ENOPROGJ));
+  rb_define_const(module, "ETOLF", INT2FIX(GSL_ETOLF));
+  rb_define_const(module, "ETOLX", INT2FIX(GSL_ETOLX));
+  rb_define_const(module, "ETOLG", INT2FIX(GSL_ETOLG));
+  rb_define_const(module, "EOF", INT2FIX(GSL_EOF));
+}
+
+static VALUE rb_gsl_set_error_handler_off(VALUE module)
+{
+  gsl_set_error_handler_off();
+  return Qtrue;
+}
+
+static void define_module_functions(VALUE module);
+static VALUE rb_gsl_strerror(VALUE obj, VALUE errn);
+static void define_module_functions(VALUE module)
+{
+  rb_define_module_function(module, "set_error_handler_off", 
+			    rb_gsl_set_error_handler_off, 0);
+  rb_define_module_function(module, "strerror", 
+			    rb_gsl_strerror, 1);
+  rb_define_module_function(module, "set_error_handler",
+			    rb_gsl_set_error_handler, -1);
+  rb_define_module_function(module, "set_default_error_handler",
+			    rb_gsl_set_default_error_handler, 0);
+}
+
+static VALUE rb_gsl_strerror(VALUE obj, VALUE errn)
+{
+  int gsl_errno = FIX2INT(errn);
+  return rb_str_new2(gsl_strerror(gsl_errno));
+}
+
+void Init_gsl_error(VALUE module)
+{
+  Init_rb_gsl_define_GSL_CONST(module);
+
+  gsl_set_error_handler(&rb_gsl_error_handler);
+
+  define_module_functions(module);
+  rb_gsl_define_exceptions(module);
+}

data/ext/extconf.rb

@@ -0,0 +1,281 @@
+require 'mkmf'
+
+
+module GSL
+  class Version
+    def initialize(str)
+      @str = str
+      @ary = str.split(".").collect { |elm| elm.to_i }
+    end
+    def to_s; @str; end
+    def inspect; @str; end
+    def >=(ver)
+      ary2 = ver.split(".").collect { |elm| elm.to_i }
+      if @ary[0] > ary2[0]; return true; end			
+      if @ary[0] < ary2[0]; return false; end
+      if @ary[1] > ary2[1]; return true; end
+      if @ary[1] < ary2[1]; return false; end
+      if @ary.size < ary2.size; return false; end
+      if @ary.size == 3 and ary2.size == 3
+        if @ary[2] < ary2[2]; return false; end
+      end		
+      return true
+    end
+    def <(ver)
+      ary2 = ver.split(".").collect { |elm| elm.to_i }
+      if @ary[0] >= ary2[0]; return false; end
+      if @ary[0] >= ary2[0]; return false; end
+      return true
+    end
+  end
+end
+
+if /mingw/ =~ RUBY_PLATFORM
+  GSL_CONFIG = "sh gsl-config"
+else
+  GSL_CONFIG = "gsl-config"
+end
+
+def gsl_config()
+  print("checking gsl cflags... ")
+  IO.popen("#{GSL_CONFIG} --cflags") do |f|
+    cflags = f.gets.chomp
+    puts(cflags)
+    $CFLAGS += " " + cflags
+  end
+  
+  IO.popen("#{GSL_CONFIG} --libs") do |f|
+    libs = f.gets.chomp
+    dir_config("cblas")
+    dir_config("atlas")
+    if have_library("cblas") and have_library("atlas")
+      libs.gsub!("-lgslcblas", "-lcblas -latlas")
+      $LOCAL_LIBS += " " + libs.gsub(" -lgslcblas", "")
+      print("checking gsl libs... ")
+      puts(libs)
+    else
+      print("checking gsl libs... ")
+      puts(libs)
+      $LOCAL_LIBS += " " + libs
+    end
+  end
+
+end
+
+def check_version(configfile)
+  
+  print("checking gsl version... ")
+  IO.popen("#{GSL_CONFIG} --version") do |f|
+    ver = GSL::Version.new(f.gets.chomp)
+    puts(ver)
+    configfile.printf("#ifndef GSL_VERSION\n#define GSL_VERSION \"#{ver}\"\n#endif\n")
+
+    if ver >= "0.9.4"
+      configfile.printf("#ifndef GSL_0_9_4_LATER\n#define GSL_0_9_4_LATER\n#endif\n")
+    else
+      configfile.close
+      raise("Ruby/GSL requires gsl-0.9.4 or later.")
+    end
+    if ver >= "1.0"
+      configfile.printf("#ifndef GSL_1_0_LATER\n#define GSL_1_0_LATER\n#endif\n")
+    end
+    if ver >= "1.1"
+      configfile.printf("#ifndef GSL_1_1_LATER\n#define GSL_1_1_LATER\n#endif\n")
+    end
+    if ver >= "1.1.1"
+      configfile.printf("#ifndef GSL_1_1_1_LATER\n#define GSL_1_1_1_LATER\n#endif\n")
+    end
+    if ver >= "1.2"
+      configfile.printf("#ifndef GSL_1_2_LATER\n#define GSL_1_2_LATER\n#endif\n")
+    end
+    if ver >= "1.3"
+      configfile.printf("#ifndef GSL_1_3_LATER\n#define GSL_1_3_LATER\n#endif\n")
+    end
+    if ver >= "1.4"
+      configfile.printf("#ifndef GSL_1_4_LATER\n#define GSL_1_4_LATER\n#endif\n")
+    end
+    if ver >= "1.4.90"
+      configfile.printf("#ifndef GSL_1_4_9_LATER\n#define GSL_1_4_9_LATER\n#endif\n")
+    end
+    
+    if ver >= "1.5.90"
+      configfile.printf("#ifndef GSL_1_6_LATER\n#define GSL_1_6_LATER\n#endif\n")
+    end
+
+    if ver >= "1.7.90"
+      configfile.printf("#ifndef GSL_1_8_LATER\n#define GSL_1_8_LATER\n#endif\n")
+    end
+    if ver >= "1.8.90"
+      configfile.printf("#ifndef GSL_1_9_LATER\n#define GSL_1_9_LATER\n#endif\n")
+    end
+
+    if ver >= "1.9.90"
+      configfile.printf("#ifndef GSL_1_10_LATER\n#define GSL_1_10_LATER\n#endif\n")
+    end    
+    if ver < "1.4"
+      configfile.printf("#ifndef GSL_CONST_OLD\n#define GSL_CONST_OLD\n#endif\n")
+    end
+
+    if ver >= "1.11"
+      configfile.printf("#ifndef GSL_1_11_LATER\n#define GSL_1_11_LATER\n#endif\n")
+    end    
+
+   if ver >= "1.12.90"
+      configfile.printf("#ifndef GSL_1_13_LATER\n#define GSL_1_13_LATER\n#endif\n")
+    end    
+  end
+end
+
+#####
+
+$CFLAGS = " -Wall -I../include "
+
+begin
+  RB_GSL_CONFIG = File.open("../include/rb_gsl_config.h", "w")
+  RB_GSL_CONFIG.printf("#ifndef ___RB_GSL_CONFIG_H___\n")
+  RB_GSL_CONFIG.printf("#define ___RB_GSL_CONFIG_H___\n\n")
+
+  check_version(RB_GSL_CONFIG)
+
+  gsl_config()
+
+  have_func("round")
+
+# Check GSL extensions
+
+  if have_header("rngextra/rngextra.h")
+    have_library("rngextra")
+  end
+
+  if have_header("qrngextra/qrngextra.h")
+    have_library("qrngextra")
+  end
+
+  if have_header("ool/ool_version.h")
+    have_library("ool")
+  end
+  
+  if have_header("tensor/tensor.h")
+    have_library("tensor")
+  end
+
+  if have_header("jacobi.h")
+    have_library("jacobi")
+  end
+  if have_header("gsl/gsl_cqp.h")
+    have_library("cqp")
+  end
+  if have_header("gsl/gsl_multimin_fsdf.h")
+    have_library("bundle_method")
+  end
+     
+  if have_library("gsl", "gsl_poly_solve_quartic")
+    RB_GSL_CONFIG.printf("#ifndef HAVE_POLY_SOLVE_QUARTIC\n#define HAVE_POLY_SOLVE_QUARTIC\n#endif\n")
+  end
+  if have_library("gsl", "gsl_eigen_francis")
+    RB_GSL_CONFIG.printf("#ifndef HAVE_EIGEN_FRANCIS\n#define HAVE_EIGEN_FRANCIS\n#endif\n")
+  end
+
+  if have_header("ndlinear/gsl_multifit_ndlinear.h")
+    have_library("ndlinear")
+  end
+
+# Added 2009/Apr/20
+  if have_header("alf/alf.h")
+    have_library("alf")
+  end
+  
+  begin
+    print("checking rb-gsl version...")
+    IO.popen("cat ../VERSION") do |f|
+      ver = GSL::Version.new(f.gets.chomp)
+      puts(ver)
+      RB_GSL_CONFIG.printf("#ifndef RUBY_GSL_VERSION\n#define RUBY_GSL_VERSION \"#{ver}\"\n#endif\n")
+    end
+  end
+
+  RUBY_VERSION2 = GSL::Version.new(RUBY_VERSION)
+  
+  puts("checking ruby version... #{RUBY_VERSION2}")
+  if RUBY_VERSION2 >= "1.8"
+    RB_GSL_CONFIG.printf("#ifndef RUBY_1_8_LATER\n#define RUBY_1_8_LATER\n#endif\n")
+
+    if find_executable("graph")
+      RB_GSL_CONFIG.printf("#ifndef HAVE_GNU_GRAPH\n#define HAVE_GNU_GRAPH\n#endif\n")
+    end
+  else
+    path = (path || ENV['PATH']).split(File::PATH_SEPARATOR)  
+    flag = 0
+    print("checking for GNU graph... ")
+    path.each do |dir|    
+      if File.executable?(file = File.join(dir, "graph")) 
+        puts("yes")
+        RB_GSL_CONFIG.printf("#ifndef HAVE_GNU_GRAPH\n#define HAVE_GNU_GRAPH\n#endif\n")
+        flag = 1
+        break
+      end
+    end
+    puts("no") if flag == 0
+  end
+  if RUBY_VERSION2 >= "1.9"
+    RB_GSL_CONFIG.printf("#ifndef RUBY_1_9_LATER\n#define RUBY_1_9_LATER\n#endif\n")
+  end
+
+  RB_GSL_CONFIG.printf("\n#endif\n")
+  RB_GSL_CONFIG.close
+  
+rescue
+  raise("Check GSL>=0.9.4 is installed, and the command \"gsl-config\" is in search path.")
+end
+
+#narray_config = dir_config("narray")
+narray_config = dir_config('narray',$sitearchdir,$sitearchdir)
+# Try to find narray with RubyGems
+begin
+  require 'rubygems'
+  na_gemspec=Gem.searcher.find('narray.h')
+  if na_gemspec
+    narray_config = File.join(na_gemspec.full_gem_path, na_gemspec.require_path)
+    $CPPFLAGS = " -I#{narray_config} "+$CPPFLAGS
+  end
+rescue LoadError
+end
+have_narray_h = have_header("narray.h")
+if narray_config
+  if RUBY_PLATFORM =~ /cygwin|mingw/
+#    have_library("narray") || raise("ERROR: narray import library is not found") 
+  have_library("narray")
+  end
+end
+
+tamu_anova_config = dir_config('tamu_anova',$sitearchdir,$sitearchdir)
+have_tamu_anova_h = have_header("tamu_anova/tamu_anova.h")
+if tamu_anova_config
+  have_library("tamuanova")
+#  if RUBY_PLATFORM =~ /cygwin|mingw/
+#    have_library("tamuanova") || raise("ERROR: tamu_anova import library is not found")
+#  end
+end
+
+File.open("../lib/gsl.rb", "w") do |file|
+  if have_narray_h
+    file.print("require('narray')\n")
+  end
+#  file.print("require('rb_gsl')\ninclude GSL\n")
+  file.print("require('rb_gsl')\n")  
+  file.print("require('gsl/oper.rb')\n")
+end
+
+File.open("../lib/rbgsl.rb", "w") do |file|
+  if have_narray_h
+    file.print("require('narray')\n")
+  end
+  file.print("require('rb_gsl')\n")
+  file.print("require('gsl/oper.rb')\n")
+end
+
+srcs = Dir.glob("*.c") - ["vector_source.c", "matrix_source.c", "tensor_source.c", "poly_source.c", "block_source.c"]
+
+$objs = srcs.collect { |f| f.sub(".c", ".o") }
+
+create_makefile("rb_gsl")