gsl 1.12.108

data/include/rb_gsl.h

@@ -0,0 +1,151 @@
+/*
+  rb_gsl.h
+  Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
+    (C) Copyright 2001-2004 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
+*/
+
+#ifndef ___RB_GSL_H___
+#define ___RB_GSL_H___
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <gsl/gsl_mode.h>
+#include "rb_gsl_common.h"
+#include "rb_gsl_math.h"
+#include "rb_gsl_complex.h"
+#include "rb_gsl_array.h"
+#include "rb_gsl_function.h"
+#include "rb_gsl_poly.h"
+#include "rb_gsl_sf.h"
+#include "rb_gsl_linalg.h"
+#include "rb_gsl_eigen.h"
+#include "rb_gsl_fft.h"
+#include "rb_gsl_integration.h"
+#include "rb_gsl_rng.h"
+#include "rb_gsl_statistics.h"
+#include "rb_gsl_histogram.h"
+#include "rb_gsl_odeiv.h"
+#include "rb_gsl_interp.h"
+#include "rb_gsl_cheb.h"
+#include "rb_gsl_root.h"
+#include "rb_gsl_fit.h"
+#include "rb_gsl_const.h"
+#include "rb_gsl_config.h"
+
+
+#include "ruby.h"
+#ifdef RUBY_1_9_LATER
+#include "ruby/io.h"
+#else
+#include "rubyio.h"
+#endif
+
+void Init_gsl_error(VALUE module);
+void Init_gsl_math(VALUE module);
+void Init_gsl_complex(VALUE module);
+void Init_gsl_array(VALUE module);
+void Init_gsl_blas(VALUE module);
+void Init_gsl_sort(VALUE module);
+void Init_gsl_poly(VALUE module);
+void Init_gsl_poly_int(VALUE module);
+void Init_gsl_poly2(VALUE module);
+void Init_gsl_rational(VALUE module);
+void Init_gsl_sf(VALUE module);
+void Init_gsl_linalg(VALUE module);
+void Init_gsl_eigen(VALUE module);
+void Init_gsl_fft(VALUE module);
+void Init_gsl_signal(VALUE module);
+void Init_gsl_function(VALUE module);
+void Init_gsl_integration(VALUE module);
+
+void Init_gsl_rng(VALUE module);
+void Init_gsl_qrng(VALUE module);
+void Init_gsl_ran(VALUE module);
+void Init_gsl_cdf(VALUE module);
+void Init_gsl_stats(VALUE module);
+
+void Init_gsl_histogram(VALUE module);
+void Init_gsl_histogram2d(VALUE module);
+void Init_gsl_histogram3d(VALUE module);
+void Init_gsl_ntuple(VALUE module);
+void Init_gsl_monte(VALUE module);
+void Init_gsl_siman(VALUE module);
+
+void Init_gsl_odeiv(VALUE module);
+void Init_gsl_interp(VALUE module);
+void Init_gsl_spline(VALUE module);
+void Init_gsl_diff(VALUE module);
+#ifdef GSL_1_4_9_LATER
+void Init_gsl_deriv(VALUE module);
+#endif
+
+void Init_gsl_cheb(VALUE module);
+void Init_gsl_sum(VALUE module);
+void Init_gsl_dht(VALUE module);
+
+void Init_gsl_root(VALUE module);
+void Init_gsl_multiroot(VALUE module);
+void Init_gsl_min(VALUE module);
+void Init_gsl_multimin(VALUE module);
+void Init_gsl_fit(VALUE module);
+void Init_gsl_multifit(VALUE module);
+
+void Init_gsl_const(VALUE module);
+
+void Init_gsl_ieee(VALUE module);
+
+#ifdef HAVE_NARRAY_H
+void Init_gsl_narray(VALUE module);
+#endif
+
+void Init_wavelet(VALUE module);
+
+void Init_gsl_graph(VALUE module);
+
+#ifdef HAVE_TENSOR_TENSOR_H
+void Init_tensor_init(VALUE module);
+void Init_tensor_int_init(VALUE module);
+#endif
+
+void Init_gsl_dirac(VALUE module);
+
+EXTERN VALUE cGSL_Object;
+
+void Init_tamu_anova(VALUE module);
+
+#ifdef HAVE_TAMU_ANOVA_TAMU_ANOVA_H
+#include "tamu_anova/tamu_anova.h"
+#endif
+
+#ifdef HAVE_OOL_OOL_VERSION_H
+void Init_ool(VALUE module);
+#endif
+
+#ifdef HAVE_JACOBI_H
+void Init_jacobi(VALUE module);
+#endif
+
+#ifdef HAVE_GSL_GSL_CQP_H
+void Init_cqp(VALUE module);
+#endif
+
+void Init_fresnel(VALUE module);
+
+#ifdef GSL_1_9_LATER
+void Init_bspline(VALUE module);
+#endif
+
+#ifdef HAVE_ALF_ALF_H
+#include "alf/alf.h"
+#endif
+void Init_alf(VALUE module);
+void Init_geometry(VALUE module);
+
+#endif

data/include/rb_gsl_array.h

@@ -0,0 +1,238 @@
+/*
+  rb_gsl_array.h
+  Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
+    (C) Copyright 2001-2004 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
+*/
+
+#ifndef ___RB_GSL_ARRAY_H___
+#define ___RB_GSL_ARRAY_H___
+
+#include <math.h>
+#include <gsl/gsl_errno.h>
+#include <gsl/gsl_complex.h>
+#include <gsl/gsl_block.h>
+#include <gsl/gsl_vector.h>
+#include <gsl/gsl_vector_complex.h>
+#include <gsl/gsl_vector_complex_double.h>
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_matrix_complex_double.h>
+#include <gsl/gsl_permutation.h>
+#include <gsl/gsl_combination.h>
+#include <gsl/gsl_sort.h>
+#include <gsl/gsl_sort_vector.h>
+#include <gsl/gsl_linalg.h>
+#include <gsl/gsl_eigen.h>
+#include <gsl/gsl_odeiv.h>
+#include <gsl/gsl_blas.h>
+#include "rb_gsl_config.h"
+
+#include "ruby.h"
+#ifdef RUBY_1_9_LATER
+#include "ruby/io.h"
+#else
+#include "rubyio.h"
+#endif
+
+#include "rb_gsl_common.h"
+
+typedef gsl_permutation gsl_index;
+
+#ifdef HAVE_NARRAY_H
+EXTERN VALUE cNArray;
+#endif
+
+EXTERN VALUE cgsl_block, cgsl_block_int;
+EXTERN VALUE cgsl_block_uchar;
+EXTERN VALUE cgsl_block_complex;
+EXTERN VALUE cgsl_vector, cgsl_vector_complex;
+EXTERN VALUE cgsl_vector_col;
+EXTERN VALUE cgsl_vector_col_view;
+EXTERN VALUE cgsl_vector_complex_col;
+EXTERN VALUE cgsl_vector_complex_col_view;
+EXTERN VALUE cgsl_vector_view, cgsl_vector_complex_view;
+EXTERN VALUE cgsl_vector_view_ro, cgsl_vector_col_view_ro;
+EXTERN VALUE cgsl_vector_complex_view_ro;
+
+EXTERN VALUE cgsl_vector_int, cgsl_vector_int_col;
+EXTERN VALUE cgsl_vector_int_view, cgsl_vector_int_col_view;
+EXTERN VALUE cgsl_vector_int_view_ro, cgsl_vector_int_col_view_ro;
+
+EXTERN VALUE cgsl_matrix, cgsl_matrix_complex;
+EXTERN VALUE cgsl_matrix_view_ro;
+EXTERN VALUE cgsl_matrix_complex_view_ro;
+EXTERN VALUE cgsl_matrix_view, cgsl_matrix_complex_view;
+EXTERN VALUE cgsl_matrix_int, cgsl_matrix_int_view;
+EXTERN VALUE cgsl_matrix_int_view_ro;
+EXTERN VALUE cgsl_permutation;
+EXTERN VALUE cgsl_index;
+EXTERN VALUE cgsl_function;
+EXTERN VALUE mgsl_narray;
+
+EXTERN VALUE mDirac;
+
+gsl_matrix_view* gsl_matrix_view_alloc();
+void gsl_matrix_view_free(gsl_matrix_view * mv);
+gsl_vector_view* gsl_vector_view_alloc();
+void gsl_vector_view_free(gsl_vector_view * v);
+gsl_vector_complex_view* gsl_vector_complex_view_alloc();
+void gsl_vector_complex_view_free(gsl_vector_view * vv);
+gsl_matrix_complex_view* gsl_matrix_complex_view_alloc();
+void gsl_matrix_complex_view_free(gsl_matrix_view * vv);
+
+VALUE rb_gsl_vector_new(int argc, VALUE *argv, VALUE klass);
+
+gsl_vector* get_cvector(VALUE v);
+VALUE make_rarray_from_cvector(const gsl_vector *v);
+VALUE make_rarray_from_cpermutation(const gsl_permutation *v);
+gsl_vector* make_cvector_from_rarrays(VALUE a);
+gsl_vector* make_cvector_from_rarray(VALUE a);
+void cvector_set_from_carray(gsl_vector *v, const double *a);
+void cvector_set_from_rarrays(gsl_vector *v, VALUE ary);
+void cvector_set_from_rarray(gsl_vector *v, VALUE ary);
+void carray_set_from_cvector(double *a, const gsl_vector *v);
+void carray_set_from_rarrays(double *a, VALUE ary);
+void carray_set_from_rarray(double *a, VALUE ary);
+int is_vector_p(VALUE obj);
+void check_vector(VALUE obj);
+int is_vector_complex_p(VALUE obj);
+void check_vector_complex(VALUE obj);
+int is_matrix_p(VALUE obj);
+void check_matrix(VALUE obj);
+int is_matrix_complex_p(VALUE obj);
+void check_matrix_complex(VALUE obj);
+gsl_complex* make_complex(double re, double im);
+int is_permutation_p(VALUE obj);
+void check_permutation(VALUE obj);
+int is_combination_p(VALUE obj);
+void check_combination(VALUE obj);
+gsl_vector* get_vector(VALUE ary);
+gsl_matrix* make_matrix_clone(const gsl_matrix *m);
+gsl_matrix_int* make_matrix_int_clone(const gsl_matrix_int *m);
+VALUE make_matrix_clone2(VALUE vm);
+gsl_matrix_complex* make_matrix_complex_clone(const gsl_matrix_complex *m);
+int is_matrix_complex_p(VALUE obj);
+void check_matrix_complex(VALUE obj);
+
+double* get_vector_ptr(VALUE ary, size_t *stride, size_t *n);
+
+
+gsl_matrix_complex* matrix_to_complex(const gsl_matrix *m);
+
+void gsl_matrix_complex_mul(gsl_matrix_complex *mnew, const gsl_matrix_complex *m, 
+			    const gsl_matrix_complex *mb);
+void gsl_matrix_mul(gsl_matrix *mnew, gsl_matrix *m, gsl_matrix *b);
+void gsl_matrix_complex_mul_vector(gsl_vector_complex *vnew, 
+				   const gsl_matrix_complex *m, 
+				   const gsl_vector_complex *v);
+void gsl_matrix_mul_vector(gsl_vector *vnew, 
+			   const gsl_matrix *m, const gsl_vector *v);
+gsl_vector_complex* vector_to_complex(const gsl_vector *v);
+
+gsl_vector* make_vector_clone(const gsl_vector *v);
+gsl_vector_complex* make_vector_complex_clone(const gsl_vector_complex *v);
+int gsl_vector_complex_add(gsl_vector_complex *cv, const gsl_vector_complex *cv2);
+int gsl_vector_complex_sub(gsl_vector_complex *cv, const gsl_vector_complex *cv2);
+int gsl_vector_complex_mul(gsl_vector_complex *cv, const gsl_vector_complex *cv2);
+int gsl_vector_complex_div(gsl_vector_complex *cv, const gsl_vector_complex *cv2);
+int gsl_vector_complex_add_constant(gsl_vector_complex *cv, gsl_complex b);
+int gsl_vector_complex_scale(gsl_vector_complex *cv, gsl_complex b);
+gsl_vector_view* rb_gsl_make_vector_view(double *data, size_t size, size_t stride);
+gsl_vector_int_view* rb_gsl_make_vector_int_view(int *data, size_t size, size_t stride);
+
+void Init_gsl_array_complex(VALUE module);
+void Init_gsl_vector(VALUE module);
+void Init_gsl_vector_complex(VALUE module);
+void Init_gsl_matrix(VALUE module);
+void Init_gsl_matrix_complex(VALUE module);
+void Init_gsl_matrix(VALUE module);
+void Init_gsl_permutation(VALUE module);
+void Init_gsl_combination(VALUE module);
+void Init_gsl_matrix_int(VALUE module);
+
+VALUE rb_gsl_range2ary(VALUE obj);
+
+void Init_gsl_vector_int();
+gsl_vector_int_view* rb_gsl_vector_int_view_alloc(size_t n);
+void rb_gsl_vector_int_view_free(gsl_vector_int_view *v);
+gsl_vector_int* make_vector_int_clone(const gsl_vector_int *v);
+gsl_matrix_int_view* rb_gsl_matrix_int_view_alloc();
+void rb_gsl_matrix_int_view_free(gsl_matrix_int_view *v);
+VALUE rb_gsl_matrix_to_i(VALUE obj);
+VALUE rb_gsl_matrix_int_to_f(VALUE obj);
+void gsl_matrix_int_mul_vector(gsl_vector_int *vnew, 
+			       const gsl_matrix_int *m, const gsl_vector_int *v);
+VALUE rb_gsl_vector_to_i(VALUE obj);
+VALUE make_rarray_from_cvector_int(const gsl_vector_int *v);
+VALUE rb_gsl_vector_int_to_f(VALUE obj);
+VALUE rb_gsl_vector_uminus(VALUE obj);
+VALUE rb_gsl_vector_print(VALUE obj);
+void gsl_vector_print(const gsl_vector *v, VALUE klass);
+int rbgsl_vector_equal(const gsl_vector *v1, const gsl_vector *v2, double eps);
+
+#ifndef GSL_1_2_LATER
+int gsl_matrix_complex_add(gsl_matrix_complex * a, const gsl_matrix_complex * b);
+int gsl_matrix_complex_sub(gsl_matrix_complex * a, const gsl_matrix_complex * b);
+int gsl_matrix_complex_mul_elements(gsl_matrix_complex * a, const gsl_matrix_complex * b);
+int gsl_matrix_complex_div_elements(gsl_matrix_complex * a, const gsl_matrix_complex * b);
+int gsl_matrix_complex_scale(gsl_matrix_complex * a, const gsl_complex x);
+int gsl_matrix_complex_add_constant(gsl_matrix_complex * a, const gsl_complex x);
+int gsl_matrix_complex_add_diagonal(gsl_matrix_complex * a, const gsl_complex x);
+#endif
+
+void Init_gsl_vector_init(VALUE module);
+void Init_gsl_vector_int_init(VALUE module);
+void Init_gsl_matrix_init(VALUE module);
+void Init_gsl_matrix_int_init(VALUE module);
+
+gsl_matrix* gsl_matrix_alloc_from_array_sizes(VALUE ary, 
+						     VALUE nn1, VALUE nn2);
+gsl_matrix* gsl_matrix_alloc_from_arrays(int argc, VALUE *argv);
+
+gsl_matrix* gsl_matrix_alloc_from_vector_sizes(VALUE ary,
+					      VALUE nn1, VALUE nn2);
+gsl_matrix* gsl_matrix_alloc_from_vectors(int argc, VALUE *argv);
+gsl_matrix_int* gsl_matrix_int_alloc_from_array_sizes(VALUE ary, 
+						     VALUE nn1, VALUE nn2);
+gsl_matrix_int* gsl_matrix_int_alloc_from_arrays(int argc, VALUE *argv);
+
+gsl_matrix_int* gsl_matrix_int_alloc_from_vector_sizes(VALUE ary,
+					      VALUE nn1, VALUE nn2);
+gsl_matrix_int* gsl_matrix_int_alloc_from_vectors(int argc, VALUE *argv);
+
+VALUE rb_gsl_matrix_do_something(VALUE obj, void (*f)(gsl_matrix *));
+VALUE rb_gsl_matrix_int_do_something(VALUE obj, void (*f)(gsl_matrix_int *));
+
+VALUE rb_gsl_matrix_power(VALUE a, VALUE b);
+VALUE rb_gsl_matrix_int_power(VALUE a, VALUE b);
+
+void mygsl_vector_shift(gsl_vector *p, size_t n);
+void mygsl_vector_int_shift(gsl_vector_int *p, size_t n);
+void mygsl_vector_shift_scale2(gsl_vector *p, size_t n);
+void mygsl_vector_int_shift_scale2(gsl_vector_int *p, size_t n);
+
+VALUE rb_gsl_vector_to_s(VALUE obj);
+VALUE rb_gsl_vector_int_to_s(VALUE obj);
+
+VALUE rb_gsl_vector_add_constant(VALUE obj, VALUE x);
+VALUE rb_gsl_vector_int_add_constant(VALUE obj, VALUE x);
+VALUE rb_gsl_vector_scale(VALUE obj, VALUE x);
+VALUE rb_gsl_vector_scale_bang(VALUE obj, VALUE x);
+VALUE rb_gsl_vector_int_scale(VALUE obj, VALUE x);
+VALUE rb_gsl_vector_int_scale_bang(VALUE obj, VALUE x);
+gsl_vector_int* make_cvector_int_from_rarray(VALUE ary);
+void cvector_int_set_from_rarray(gsl_vector_int *v, VALUE ary);
+VALUE rb_gsl_range2vector(VALUE obj);
+VALUE rb_gsl_range2vector_int(VALUE obj);
+
+void Init_gsl_block_init(VALUE module);
+void Init_gsl_block_int_init(VALUE module);
+void Init_gsl_block_uchar_init(VALUE module);
+
+void Init_gsl_matrix_nmf(void);
+
+#endif

data/include/rb_gsl_cheb.h

@@ -0,0 +1,21 @@
+/*
+  rb_gsl_cheb.h
+  Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
+    (C) Copyright 2001-2004 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; without even the implied warranty of
+  MERCHANTABILITY or CHEBNESS FOR A PARTICULAR PURPOSE.
+*/
+
+#ifndef ___RB_GSL_CHEB_H___
+#define ___RB_GSL_CHEB_H___
+
+#include "rb_gsl.h"
+#include "rb_gsl_function.h"
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_chebyshev.h>
+
+#endif

data/include/rb_gsl_common.h

@@ -0,0 +1,343 @@
+/*
+  rb_gsl_common.h
+  Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
+    (C) Copyright 2001-2004 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; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+#ifndef ___RB_GSL_COMMON_H___
+#define ___RB_GSL_COMMON_H___
+
+#include "rb_gsl_config.h"
+#include "ruby.h"
+#include <ctype.h>
+#include <gsl/gsl_errno.h>
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_complex.h>
+#include <gsl/gsl_vector.h>
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_permutation.h>
+#include <gsl/gsl_ieee_utils.h>
+#ifdef HAVE_NARRAY_H
+#include "narray.h"
+#endif
+
+EXTERN ID rb_gsl_id_beg, rb_gsl_id_end, rb_gsl_id_excl, rb_gsl_id_to_a;
+
+#ifndef CHECK_FIXNUM
+#define CHECK_FIXNUM(x) if(!FIXNUM_P(x))rb_raise(rb_eTypeError,"Fixnum expected");
+#endif
+
+#ifndef Need_Float
+#define Need_Float(x) (x) = rb_Float(x)
+#endif
+
+#ifndef Need_Float2
+#define Need_Float2(x,y) do {\
+    Need_Float(x);\
+    Need_Float(y);} while (0)
+#endif
+
+#ifndef COMPLEX_P
+#define COMPLEX_P(x) (rb_obj_is_kind_of(x,cgsl_complex))
+#endif
+
+#ifndef CHECK_RNG
+#define CHECK_RNG(x) if(!rb_obj_is_kind_of(x,cgsl_rng))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Rng expected)");
+#endif
+
+#ifndef CHECK_COMPLEX
+#define CHECK_COMPLEX(x) if(!rb_obj_is_kind_of(x,cgsl_complex))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Complex expected)");
+#endif
+
+#ifndef POLY_P
+#define POLY_P(x) (rb_obj_is_kind_of(x,cgsl_poly))
+#endif
+
+#ifndef CHECK_POLY
+#define CHECK_POLY(x) if(!rb_obj_is_kind_of(x,cgsl_poly))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Poly expected)");
+#endif
+
+#ifndef CHECK_POLY_INT
+#define CHECK_POLY_INT(x) if(!rb_obj_is_kind_of(x,cgsl_poly_int))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Poly::Int expected)");
+#endif
+
+#ifndef RATIONAL_P
+#define RATIONAL_P(x) (rb_obj_is_kind_of(x,cgsl_rational))
+#endif
+
+#ifndef CHECK_RATIONAL
+#define CHECK_RATIONAL(x) if(!rb_obj_is_kind_of(x,cgsl_rational))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Rational expected)");
+#endif
+
+/*****/
+#ifndef BLOCK_P
+#define BLOCK_P(x) (rb_obj_is_kind_of(x,cgsl_block))
+#endif
+
+#ifndef CHECK_BLOCK
+#define CHECK_BLOCK(x) if(!rb_obj_is_kind_of(x,cgsl_block))\
+    rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Block expected)", rb_class2name(CLASS_OF(x)));
+#endif
+#ifndef BLOCK_INT_P
+#define BLOCK_INT_P(x) (rb_obj_is_kind_of(x,cgsl_block_int))
+#endif
+
+#ifndef CHECK_BLOCK_INT
+#define CHECK_BLOCK_INT(x) if(!rb_obj_is_kind_of(x,cgsl_block_int))\
+    rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Block::Int expected)", rb_class2name(CLASS_OF(x)));
+#endif
+#ifndef BLOCK_UCHAR_P
+#define BLOCK_UCHAR_P(x) (rb_obj_is_kind_of(x,cgsl_block_uchar))
+#endif
+
+#ifndef CHECK_BLOCK_UCHAR
+#define CHECK_BLOCK_UCHAR(x) if(!rb_obj_is_kind_of(x,cgsl_block_uchar))\
+    rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Block::Byte expected)", rb_class2name(CLASS_OF(x)));
+#endif
+/*****/
+
+#ifndef VECTOR_P
+#define VECTOR_P(x) (rb_obj_is_kind_of(x,cgsl_vector))
+#endif
+
+#ifndef VECTOR_VIEW_P
+#define VECTOR_VIEW_P(x) ((CLASS_OF(x)==cgsl_vector_view||CLASS_OF(x)==cgsl_vector_col_view||CLASS_OF(x)==cgsl_vector_view_ro||CLASS_OF(x)==cgsl_vector_col_view_ro))
+#endif
+
+#ifndef VECTOR_ROW_P
+#define VECTOR_ROW_P(x) ((CLASS_OF(x)==cgsl_vector||CLASS_OF(x)==cgsl_vector_view||CLASS_OF(x)==cgsl_vector_view_ro))
+#endif
+
+#ifndef VECTOR_COL_P
+#define VECTOR_COL_P(x) ((CLASS_OF(x)==cgsl_vector_col||CLASS_OF(x)==cgsl_vector_col_view||CLASS_OF(x)==cgsl_vector_col_view_ro))
+#endif
+
+#ifndef VECTOR_ROW_COL
+#define VECTOR_ROW_COL(x) ((rb_obj_is_kind_of(x,cgsl_vector_col)||rb_obj_is_kind_of(x,cgsl_vector_int_col))?cgsl_vector_col:cgsl_vector)
+#endif
+
+#ifndef CHECK_VECTOR
+#define CHECK_VECTOR(x) if(!rb_obj_is_kind_of(x,cgsl_vector))\
+    rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector expected)", rb_class2name(CLASS_OF(x)));
+#endif
+
+#ifdef HAVE_NARRAY_H
+#define Data_Get_Vector(obj,sval) do {\
+    if (NA_IsNArray(obj)) {\
+      (sval)->data = NA_PTR_TYPE(obj,double*);\
+      (sval)->size = NA_TOTAL(obj);\
+      (sval)->stride = 1;\
+    } else {\
+      CHECK_VECTOR(obj);\
+      Data_Get_Struct(obj,gsl_vector,sval);\
+    }\
+} while (0)
+#else
+#define Data_Get_Vector(obj,sval) do {\
+    CHECK_VECTOR(obj);\
+    Data_Get_Struct(obj,gsl_vector,sval);\
+} while (0)
+#endif
+
+/******/
+#ifndef VECTOR_INT_P
+#define VECTOR_INT_P(x) (rb_obj_is_kind_of(x,cgsl_vector_int))
+#endif
+
+#ifndef VECTOR_INT_VIEW_P
+#define VECTOR_INT_VIEW_P(x) ((CLASS_OF(x)==cgsl_vector_int_view||CLASS_OF(x)==cgsl_vector_int_col_view||CLASS_OF(x)==cgsl_vector_int_view_ro||CLASS_OF(x)==cgsl_vector_int_col_view_ro))
+#endif
+
+#ifndef VECTOR_INT_ROW_P
+#define VECTOR_INT_ROW_P(x) ((CLASS_OF(x)==cgsl_vector_int||CLASS_OF(x)==cgsl_vector_int_view||CLASS_OF(x)==cgsl_vector_int_view_ro))
+#endif
+
+#ifndef VECTOR_INT_COL_P
+#define VECTOR_INT_COL_P(x) ((CLASS_OF(x)==cgsl_vector_int_col||CLASS_OF(x)==cgsl_vector_int_col_view||CLASS_OF(x)==cgsl_vector_int_col_view_ro))
+#endif
+
+#ifndef VECTOR_INT_ROW_COL
+#define VECTOR_INT_ROW_COL(x) (VECTOR_INT_ROW_P(x)?cgsl_vector_int:cgsl_vector_int_col)
+#endif
+
+#ifndef CHECK_VECTOR_INT
+#define CHECK_VECTOR_INT(x) if(!rb_obj_is_kind_of(x,cgsl_vector_int))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Vector::Int expected)");
+#endif
+
+/******/
+#ifndef VECTOR_COMPLEX_P
+#define VECTOR_COMPLEX_P(x) (rb_obj_is_kind_of(x,cgsl_vector_complex))
+#endif
+
+#ifndef VECTOR_COMPLEX_ROW_P
+#define VECTOR_COMPLEX_ROW_P(x) ((CLASS_OF(x)==cgsl_vector_complex||CLASS_OF(x)==cgsl_vector_complex_view))
+#endif
+
+#ifndef VECTOR_COMPLEX_COL_P
+#define VECTOR_COMPLEX_COL_P(x) ((CLASS_OF(x)==cgsl_vector_complex_col||CLASS_OF(x)==cgsl_vector_complex_col_view))
+#endif
+
+#ifndef VECTOR_COMPLEX_ROW_COL
+#define VECTOR_COMPLEX_ROW_COL(x) (VECTOR_COMPLEX_ROW_P(x)?cgsl_vector_complex:cgsl_vector_complex_col)
+#endif
+
+#ifndef CHECK_VECTOR_COMPLEX
+#define CHECK_VECTOR_COMPLEX(x) if(!rb_obj_is_kind_of(x,cgsl_vector_complex))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Vector::Complex expected)");
+#endif
+
+#ifndef MATRIX_P
+#define MATRIX_P(x) (rb_obj_is_kind_of(x,cgsl_matrix))
+#endif
+
+#ifndef CHECK_MATRIX
+#define CHECK_MATRIX(x) if(!rb_obj_is_kind_of(x,cgsl_matrix))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Matrix expected)");
+#endif
+
+#define Data_Get_Matrix(obj,sval) do {\
+    CHECK_MATRIX(obj);\
+    Data_Get_Struct(obj,gsl_matrix,sval);\
+} while (0)
+
+
+#ifndef MATRIX_INT_P
+#define MATRIX_INT_P(x) (rb_obj_is_kind_of(x,cgsl_matrix_int))
+#endif
+
+#ifndef CHECK_MATRIX_INT
+#define CHECK_MATRIX_INT(x) if(!rb_obj_is_kind_of(x,cgsl_matrix_int))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Matrix::Int expected)");
+#endif
+
+#ifndef MATRIX_COMPLEX_P
+#define MATRIX_COMPLEX_P(x) (rb_obj_is_kind_of(x,cgsl_matrix_complex))
+#endif
+
+#ifndef CHECK_MATRIX_COMPLEX
+#define CHECK_MATRIX_COMPLEX(x) if(!rb_obj_is_kind_of(x,cgsl_matrix_complex))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Matrix::Complex expected)");
+#endif
+
+#ifndef TENSOR_P
+#define TENSOR_P(x) ((CLASS_OF(x)==cgsl_tensor))
+#endif
+
+#ifndef CHECK_TENSOR
+#define CHECK_TENSOR(x) if(CLASS_OF(x)!=cgsl_tensor)\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Tensor expected)");
+#endif
+
+#ifndef TENSOR_INT_P
+#define TENSOR_INT_P(x) ((CLASS_OF(x)==cgsl_tensor_int))
+#endif
+
+#ifndef CHECK_TENSOR_INT
+#define CHECK_TENSOR_INT(x) if(CLASS_OF(x)!=cgsl_tensor_int)\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Tensor::Int expected)");
+#endif
+
+#ifndef PERMUTATION_P
+#define PERMUTATION_P(x) (rb_obj_is_kind_of(x,cgsl_permutation))
+#endif
+
+#ifndef CHECK_PERMUTATION
+#define CHECK_PERMUTATION(x) if(!rb_obj_is_kind_of(x,cgsl_permutation))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Permutation expected)");
+#endif
+
+#ifndef PROC_P
+#define PROC_P(x) (rb_obj_is_kind_of(x,rb_cProc))
+#endif
+
+#ifndef CHECK_PROC
+#define CHECK_PROC(x) if(!rb_obj_is_kind_of(x,rb_cProc))\
+    rb_raise(rb_eTypeError, "wrong argument type (Proc expected)");
+#endif
+
+#ifndef FUNCTION_P
+#define FUNCTION_P(x) (rb_obj_is_kind_of(x,cgsl_function))
+#endif
+
+#ifndef CHECK_FUNCTION
+#define CHECK_FUNCTION(x) if(!rb_obj_is_kind_of(x,cgsl_function))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Function expected)");
+#endif
+
+#ifndef FUNCTION_FDF_P
+#define FUNCTION_FDF_P(x) (rb_obj_is_kind_of(x,cgsl_function_fdf))
+#endif
+
+#ifndef CHECK_FUNCTION_FDF
+#define CHECK_FUNCTION_FDF(x) if(!rb_obj_is_kind_of(x,cgsl_function_fdf))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Function_fdf expected)");
+#endif
+
+#ifndef HISTOGRAM_P
+#define HISTOGRAM_P(x) (rb_obj_is_kind_of(x,cgsl_histogram))
+#endif
+
+#ifndef CHECK_HISTOGRAM
+#define CHECK_HISTOGRAM(x) if(!rb_obj_is_kind_of(x,cgsl_histogram))\
+    rb_raise(rb_eTypeError, "wrong argument type (GSL::Histogram expected)");
+#endif
+
+void rb_gsl_error_handler(const char *reason, const char *file,
+				 int line, int gsl_errno);
+
+FILE* rb_gsl_open_writefile(VALUE io, int *flag);
+FILE* rb_gsl_open_readfile(VALUE io, int *flag);
+
+VALUE rb_gsl_obj_read_only(int argc, VALUE *argv, VALUE obj);
+
+int str_tail_grep(const char *s0, const char *s1);
+int str_head_grep(const char *s0, const char *s1);
+
+#ifdef RUBY_1_8_LATER
+#define RB_GSL_MAKE_PROC rb_block_proc()
+#define STR2CHARPTR StringValuePtr
+#else
+#define RB_GSL_MAKE_PROC rb_f_lambda()
+#define STR2CHARPTR STR2CSTR
+#endif
+
+void make_graphcommand(char *command, VALUE hash);
+int rbgsl_complex_equal(const gsl_complex *z1, const gsl_complex *z2, double eps);
+
+gsl_vector* mygsl_vector_down(gsl_vector *p);
+void mygsl_vector_up2(gsl_vector *pnew, gsl_vector *p);
+gsl_vector* mygsl_vector_up(gsl_vector *p);
+
+gsl_vector_int* mygsl_vector_int_down(gsl_vector_int *p);
+void mygsl_vector_int_up2(gsl_vector_int *pnew, gsl_vector_int *p);
+gsl_vector_int* mygsl_vector_int_up(gsl_vector_int *p);
+
+#ifndef GSL_1_3_LATER
+int gsl_fcmp(const double x1, const double x2, const double epsilon);
+#endif
+
+size_t count_columns(const char *str);
+char* str_scan_double(const char *str, double *val);
+char* str_scan_int(const char *str, int *val);
+double* get_ptr_double3(VALUE obj, size_t *size, size_t *stride, int *flag);
+gsl_complex ary2complex(VALUE obj);
+VALUE vector_eval_create(VALUE obj, double (*func)(double));
+VALUE matrix_eval_create(VALUE obj, double (*func)(double));
+VALUE rb_gsl_ary_eval1(VALUE ary, double (*f)(double));
+#ifdef HAVE_NARRAY_H
+VALUE rb_gsl_nary_eval1(VALUE ary, double (*f)(double));
+#endif
+
+EXTERN VALUE cGSL_Object;
+#endif