numo-gsl 0.1.0

data/ext/numo/gsl/histogram/tmpl/c_DFloat_f_2d_get.c

@@ -0,0 +1,54 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n, i;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+    ssize_t  x1, x2;
+    size_t   y1, y2;
+    double   y3;
+    <%=struct%> *w = (<%=struct%>*)(lp->opt_ptr);
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+
+    for (i=0; i<n; i++) {
+        GET_DATA_STRIDE(p1,s1,ssize_t,x1);
+        GET_DATA_STRIDE(p2,s2,ssize_t,x2);
+        if (x1 < 0) {
+            y1 = x1 + w->nx;
+        } else {
+            y1 = x1;
+        }
+        if (x2 < 0) {
+            y2 = x2 + w->ny;
+        } else {
+            y2 = x2;
+        }
+        y3 = <%=func_name%>(<%=get(:postpose) ? "y1,y2,w" : "w,y1,y2"%>);
+        SET_DATA_STRIDE(p3,s3,double,y3);
+    }
+}
+
+/*
+  @overload <%=name%>(<%=args[1][1]%>, <%=args[2][1]%>)
+  @param  [Int32/64]  <%=args[1][1]%>
+  @param  [Int32/64]  <%=args[2][1]%>
+  @return [<%=class_name%>]  self
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(2)%>(VALUE self, VALUE v1, VALUE v2)
+{
+    <%=struct%> *w;
+    ndfunc_arg_in_t ain[2] = {{cSSZ,0},{cSSZ,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = {iter_<%=c_func%>, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    return na_ndloop3(&ndf, w, 2, v1, v2);
+}

data/ext/numo/gsl/histogram/tmpl/c_DFloat_f_field.c

@@ -0,0 +1,35 @@
+<% nd = (/histogram2d/ =~ struct) ? 2 : 1 %>
+/*
+  @overload <%=name%>()
+  @return [DFloat]    narray of <%=name%> field in <%=struct%>.
+
+  returns <%=name%> field in <%=struct%> struct.
+  <%= description %>
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    <%=struct%> *w;
+    double *d;
+    VALUE v;
+    size_t n, i, shape[<%=nd%>];
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    <%if /([xy]?)range/ =~ name %>
+    shape[0] = n = w->n<%=$1%>+1;
+    <%elsif nd==1%>
+    shape[0] = n = w->n;
+    <%else%>
+    n = w->nx * w->ny;
+    shape[0] = w->nx;
+    shape[1] = w->ny;
+    <%end%>
+
+    v = rb_narray_new(cDF, <%=nd%>, shape);
+    d = (double*)na_get_pointer_for_write(v);
+    for (i=0; i<n; i++) {
+        d[i] = w-><%=name%>[i];
+    }
+    return v;
+}

data/ext/numo/gsl/histogram/tmpl/c_DFloat_f_get.c

@@ -0,0 +1,47 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n, i;
+    char    *p1, *p2;
+    ssize_t  s1, s2;
+    ssize_t  x1;
+    size_t   y1;
+    double   y2;
+    <%=struct%> *w = (<%=struct%>*)(lp->opt_ptr);
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+
+    for (i=0; i<n; i++) {
+        GET_DATA_STRIDE(p1,s1,ssize_t,x1);
+        if (x1 < 0) {
+            y1 = x1 + w->n;
+        } else {
+            y1 = x1;
+        }
+        y2 = <%=func_name%>(<%=get(:postpose) ? "y1,w" : "w,y1"%>);
+        SET_DATA_STRIDE(p2,s2,double,y2);
+    }
+}
+#undef FUNC
+
+/*
+  @overload <%=name%>(<%=args[1][1]%>)
+  @param  [Int32/64]  <%=args[1][1]%>
+  @return [<%=class_name%>]  self
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE v1)
+{
+    <%=struct%> *w;
+    ndfunc_arg_in_t ain[1] = {{cSSZ,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = {iter_<%=c_func%>, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    return na_ndloop3(&ndf, w, 1, v1);
+}

data/ext/numo/gsl/histogram/tmpl/c_DFloat_x2_f_get_range.c

@@ -0,0 +1,56 @@
+<%
+n = case name
+    when /_xrange/; "nx"
+    when /_yrange/; "ny"
+    when /_range/;  "n"
+    end
+%>
+
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n, i;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+    ssize_t  x1;
+    size_t   y1;
+    double   y2, y3;
+    <%=struct%> *w = (<%=struct%>*)(lp->opt_ptr);
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+
+    for (i=0; i<n; i++) {
+        GET_DATA_STRIDE(p1,s1,ssize_t,x1);
+        if (x1 < 0) {
+            y1 = x1 + w-><%=n%>;
+        } else {
+            y1 = x1;
+        }
+        <%=func_name%>(<%=get(:postpose) ? "y1,&y2,&y3,w" : "w,y1,&y2,&y3"%>);
+        SET_DATA_STRIDE(p2,s2,double,y2);
+        SET_DATA_STRIDE(p3,s3,double,y3);
+    }
+}
+
+/*
+  @overload <%=name%>(<%=args[1][1]%>)
+  @param  [Int32/64]  <%=args[1][1]%>  Int32/64 NArray
+  @return [Array]     array of [[DFloat] <%=args[2][1]%>, [DFloat] <%=args[3][1]%>]
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE v1)
+{
+    <%=struct%> *w;
+    ndfunc_arg_in_t ain[1] = {{cSSZ,0}};
+    ndfunc_arg_out_t aout[2] = {{cDF,0},{cDF,0}};
+    ndfunc_t ndf = {iter_<%=c_func%>, STRIDE_LOOP|NDF_EXTRACT, 1,2, ain,aout};
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    return na_ndloop3(&ndf, w, 1, v1);
+}

data/ext/numo/gsl/histogram/tmpl/c_bool_f_other.c

@@ -0,0 +1,19 @@
+/*
+  @overload <%=name%>(<%=args[1][1]%>)
+  @param  [<%=class_name%>] <%=args[1][1]%>
+  @return [Bool]
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE v1)
+{
+    int stat;
+    <%=struct%> *w, *w1;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+    TypedData_Get_Struct(v1, <%=struct%>, &<%=data_type_var%>, w1);
+
+    stat = <%=func_name%>(w, w1);
+    return (stat) ? Qtrue: Qfalse;
+}

data/ext/numo/gsl/histogram/tmpl/c_bool_f_pdf_init.c

@@ -0,0 +1,24 @@
+<%
+h_struct = struct.sub(/_pdf/,"")
+h_data_type_var = data_type_var.sub(/_pdf/,"")
+%>
+/*
+  @overload <%=name%>(<%=args[1][1]%>)
+  @param  [<%=class_name%>] <%=args[1][1]%>
+  @return [Bool]
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE v1)
+{
+    int stat;
+    <%=struct%> *w;
+    <%=h_struct%> *w1;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+    TypedData_Get_Struct(v1, <%=h_struct%>, &<%=h_data_type_var%>, w1);
+
+    stat = <%=func_name%>(w, w1);
+    return (stat) ? Qtrue: Qfalse;
+}

data/ext/numo/gsl/histogram/tmpl/c_self_f_2d_set_ranges.c

@@ -0,0 +1,26 @@
+/*
+  @overload <%=name%>(<%=args[1][1]%>,<%=args[3][1]%>)
+  @param  [DFloat]   <%=args[1][1]%>
+  @param  [DFloat]   <%=args[3][1]%>
+  @return [<%=class_name%>]  self
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(2)%>(VALUE self, VALUE v1, VALUE v2)
+{
+    <%=struct%> *w;
+    double *p1, *p2;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    v1 = cast_1d_contiguous(v1, cDF);
+    p1 = (double*)na_get_pointer_for_read(v1);
+    v2 = cast_1d_contiguous(v2, cDF);
+    p2 = (double*)na_get_pointer_for_read(v2);
+
+    <%=func_name%>(w, p1, RNARRAY_SIZE(v1), p2, RNARRAY_SIZE(v2));
+    RB_GC_GUARD(v1);
+    RB_GC_GUARD(v2);
+    return self;
+}

data/ext/numo/gsl/histogram/tmpl/c_self_f_set_ranges.c

@@ -0,0 +1,21 @@
+/*
+  @overload <%=name%>(<%=args[1][1]%>)
+  @param  [DFloat]   <%=args[1][1]%>
+  @return [<%=class_name%>]  self
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE v1)
+{
+    <%=struct%> *w;
+    double *p1;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    v1 = cast_1d_contiguous(v1, cDF);
+    p1 = (double*)na_get_pointer_for_read(v1);
+    <%=func_name%>(w, p1, RNARRAY_SIZE(v1));
+    RB_GC_GUARD(v1);
+    return self;
+}

data/ext/numo/gsl/histogram/tmpl/c_sizet_f_field.c

@@ -0,0 +1,15 @@
+/*
+  @overload <%=name%>
+  @return [Integer]
+
+  returns <%=name%> field in <%=struct%> struct.
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    <%=struct%> *w;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    return SIZET2NUM(w-><%=name%>);
+}

data/ext/numo/gsl/interp/depend

@@ -0,0 +1,17 @@
+COGEN=ruby erbpp_interp.rb
+GENSRC=gsl_interp.c
+GENDEPS=erbpp_interp.rb ../gen/*.rb ../gen/tmpl/*.c tmpl/*.c
+
+src : $(GENSRC)
+
+$(GENSRC) : $(GENDEPS)
+	$(COGEN) > $@
+
+doc : $(GENSRC)
+	yard doc $(GENSRC)
+
+clean: cleansrc cleandoc
+cleansrc:
+	-$(Q)$(RM) $(GENSRC)
+cleandoc:
+	-$(Q)$(RM_RF) doc .yardoc

data/ext/numo/gsl/interp/erbpp_interp.rb

@@ -0,0 +1,59 @@
+require_relative "parse_interp"
+require "erbpp/line_number"
+
+gsl_list = ErbppGsl.read_func_pattern(
+ [/^gsl_interp_accel_(\w+)$/,    interp_accel_list=[]],
+ [/^gsl_interp2d_(\w+)$/,    interp2d_list=[]],
+ [/^gsl_interp_(\w+)$/,    interp_list=[]],
+ [/^gsl_spline2d_(\w+)$/,    spline2d_list=[]],
+ [/^gsl_spline_(\w+)$/,    spline_list=[]],
+)
+
+desc = {}
+gsl_list.each do |h|
+  desc[h[:func_name]] = h[:desc]
+end
+gsl_list.each do |h|
+  if /^gsl_spline/ =~ h[:func_name] && h[:desc].empty?
+    h[:desc] = desc[h[:func_name].sub(/_spline/,"_interp")]
+  end
+end
+
+DefLib.new do
+  set erb_dir: %w[tmpl ../gen/tmpl]
+  set erb_suffix: ".c"
+  set ns_var: "mG"
+
+  ErbPP.new(self,"cast_1d_contiguous")
+  ErbPP.new(self,"cast_2d_contiguous")
+
+  name = "Interp"
+  set file_name: "gsl_#{name}.c"
+  set include_files: %w[gsl/gsl_interp.h gsl/gsl_interp2d.h
+                        gsl/gsl_spline.h gsl/gsl_spline2d.h]
+  set lib_name: name.downcase
+
+  [
+   #["Interp",      "interp",       interp_list],
+   ["InterpAccel", "interp_accel", interp_accel_list],
+   #["Interp2D",    "interp2d",     interp2d_list],
+   ["Spline",      "spline",       spline_list],
+   ["Spline2D",    "spline2d",     spline2d_list],
+  ].each do |name,base,list|
+
+    DefInterp.new(self) do
+      set name: base
+      set class_name: name
+      set class_var: "c"+name
+      set full_class_name: "Numo::GSL::"+name
+      set struct: "gsl_"+base
+
+      undef_alloc_func
+      init = nil
+      list.each do |h|
+        check_func(h)
+      end
+    end
+
+  end
+end.run

data/ext/numo/gsl/interp/extconf.rb

@@ -0,0 +1,9 @@
+require_relative '../extconf_gsl.rb'
+
+# source file to compile
+srcs = %w(
+ gsl_interp
+)
+$objs = srcs.collect{|i| i+".o"}
+
+create_makefile('numo/gsl/interp')

data/ext/numo/gsl/interp/func_def.rb

@@ -0,0 +1,816 @@
+[{:func_name=>"gsl_interp_alloc",
+  :func_type=>"gsl_interp *",
+  :args=>[["const gsl_interp_type *", "T"], ["size_t", "size"]],
+  :desc=>
+   "This function returns a pointer to a newly allocated interpolation\n" +
+   "object of type T for size data-points."},
+ {:func_name=>"gsl_interp_init",
+  :func_type=>"int",
+  :args=>
+   [["gsl_interp *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["size_t", "size"]],
+  :desc=>
+   "This function initializes the interpolation object interp for the\n" +
+   "data (xa,ya) where xa and ya are arrays of size\n" +
+   "size.  The interpolation object (gsl_interp) does not save\n" +
+   "the data arrays xa and ya and only stores the static state\n" +
+   "computed from the data.  The xa data array is always assumed to be\n" +
+   "strictly ordered, with increasing x values; \n" +
+   "the behavior for other arrangements is not defined."},
+ {:func_name=>"gsl_interp_free",
+  :func_type=>"void",
+  :args=>[["gsl_interp *", "interp"]],
+  :desc=>"This function frees the interpolation object interp."},
+ {:func_name=>"gsl_interp_name",
+  :func_type=>"const char *",
+  :args=>[["const gsl_interp *", "interp"]],
+  :desc=>
+   "This function returns the name of the interpolation type used by interp.\n" +
+   "For example,\n" +
+   "\n" +
+   "printf (\"interp uses '%s' interpolation.\\n\", \n" +
+   "        gsl_interp_name (interp));\n" +
+   "\n" +
+   "would print something like,\n" +
+   "\n" +
+   "interp uses 'cspline' interpolation."},
+ {:func_name=>"gsl_interp_min_size",
+  :func_type=>"unsigned int",
+  :args=>[["const gsl_interp *", "interp"]],
+  :desc=>
+   "These functions return the minimum number of points required by the\n" +
+   "interpolation object interp or interpolation type T.  For\n" +
+   "example, Akima spline interpolation requires a minimum of 5 points."},
+ {:func_name=>"gsl_interp_type_min_size",
+  :func_type=>"unsigned int",
+  :args=>[["const gsl_interp_type *", "T"]],
+  :desc=>
+   "These functions return the minimum number of points required by the\n" +
+   "interpolation object interp or interpolation type T.  For\n" +
+   "example, Akima spline interpolation requires a minimum of 5 points."},
+ {:func_name=>"gsl_interp_bsearch",
+  :func_type=>"size_t",
+  :args=>
+   [["const double", "x_array[]"],
+    ["double", "x"],
+    ["size_t", "index_lo"],
+    ["size_t", "index_hi"]],
+  :desc=>
+   "This function returns the index i of the array x_array such\n" +
+   "that x_array[i] <= x < x_array[i+1].  The index is searched for\n" +
+   "in the range [index_lo,index_hi].  "},
+ {:func_name=>"gsl_interp_accel_alloc",
+  :func_type=>"gsl_interp_accel *",
+  :args=>[["", "void"]],
+  :desc=>
+   "This function returns a pointer to an accelerator object, which is a\n" +
+   "kind of iterator for interpolation lookups.  It tracks the state of\n" +
+   "lookups, thus allowing for application of various acceleration\n" +
+   "strategies."},
+ {:func_name=>"gsl_interp_accel_find",
+  :func_type=>"size_t",
+  :args=>
+   [["gsl_interp_accel *", "a"],
+    ["const double", "x_array[]"],
+    ["size_t", "size"],
+    ["double", "x"]],
+  :desc=>
+   "This function performs a lookup action on the data array x_array\n" +
+   "of size size, using the given accelerator a.  This is how\n" +
+   "lookups are performed during evaluation of an interpolation.  The\n" +
+   "function returns an index i such that x_array[i] <= x <\n" +
+   "x_array[i+1].  "},
+ {:func_name=>"gsl_interp_accel_reset",
+  :func_type=>"int",
+  :args=>[["gsl_interp_accel *", "acc"]],
+  :desc=>
+   "This function reinitializes the accelerator object acc.  It\n" +
+   "should be used when the cached information is no longer\n" +
+   "applicable---for example, when switching to a new dataset."},
+ {:func_name=>"gsl_interp_accel_free",
+  :func_type=>"void",
+  :args=>[["gsl_interp_accel*", "acc"]],
+  :desc=>"This function frees the accelerator object acc."},
+ {:func_name=>"gsl_interp_eval",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"]],
+  :desc=>
+   "These functions return the interpolated value of y for a given\n" +
+   "point x, using the interpolation object interp, data\n" +
+   "arrays xa and ya and the accelerator acc.  When\n" +
+   "x is outside the range of xa, the error code\n" +
+   "GSL_EDOM is returned with a value of GSL_NAN for\n" +
+   "y."},
+ {:func_name=>"gsl_interp_eval_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"],
+    ["double *", "y"]],
+  :desc=>
+   "These functions return the interpolated value of y for a given\n" +
+   "point x, using the interpolation object interp, data\n" +
+   "arrays xa and ya and the accelerator acc.  When\n" +
+   "x is outside the range of xa, the error code\n" +
+   "GSL_EDOM is returned with a value of GSL_NAN for\n" +
+   "y."},
+ {:func_name=>"gsl_interp_eval_deriv",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"]],
+  :desc=>
+   "These functions return the derivative d of an interpolated\n" +
+   "function for a given point x, using the interpolation object\n" +
+   "interp, data arrays xa and ya and the accelerator\n" +
+   "acc. "},
+ {:func_name=>"gsl_interp_eval_deriv_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"],
+    ["double *", "d"]],
+  :desc=>
+   "These functions return the derivative d of an interpolated\n" +
+   "function for a given point x, using the interpolation object\n" +
+   "interp, data arrays xa and ya and the accelerator\n" +
+   "acc. "},
+ {:func_name=>"gsl_interp_eval_deriv2",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"]],
+  :desc=>
+   "These functions return the second derivative d2 of an interpolated\n" +
+   "function for a given point x, using the interpolation object\n" +
+   "interp, data arrays xa and ya and the accelerator\n" +
+   "acc. "},
+ {:func_name=>"gsl_interp_eval_deriv2_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"],
+    ["double *", "d2"]],
+  :desc=>
+   "These functions return the second derivative d2 of an interpolated\n" +
+   "function for a given point x, using the interpolation object\n" +
+   "interp, data arrays xa and ya and the accelerator\n" +
+   "acc. "},
+ {:func_name=>"gsl_interp_eval_integ",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["double", "a"],
+    ["double", "b"],
+    ["gsl_interp_accel *", "acc"]],
+  :desc=>
+   "These functions return the numerical integral result of an\n" +
+   "interpolated function over the range [a, b], using the\n" +
+   "interpolation object interp, data arrays xa and ya and\n" +
+   "the accelerator acc."},
+ {:func_name=>"gsl_interp_eval_integ_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["double", "a"],
+    ["double", "b"],
+    ["gsl_interp_accel *", "acc"],
+    ["double *", "result"]],
+  :desc=>
+   "These functions return the numerical integral result of an\n" +
+   "interpolated function over the range [a, b], using the\n" +
+   "interpolation object interp, data arrays xa and ya and\n" +
+   "the accelerator acc."},
+ {:func_name=>"gsl_spline_alloc",
+  :func_type=>"gsl_spline *",
+  :args=>[["const gsl_interp_type *", "T"], ["size_t", "size"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_init",
+  :func_type=>"int",
+  :args=>
+   [["gsl_spline *", "spline"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["size_t", "size"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_free",
+  :func_type=>"void",
+  :args=>[["gsl_spline *", "spline"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_name",
+  :func_type=>"const char *",
+  :args=>[["const gsl_spline *", "spline"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_min_size",
+  :func_type=>"unsigned int",
+  :args=>[["const gsl_spline *", "spline"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_eval",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline *", "spline"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_eval_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline *", "spline"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"],
+    ["double *", "y"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_eval_deriv",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline *", "spline"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_eval_deriv_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline *", "spline"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"],
+    ["double *", "d"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_eval_deriv2",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline *", "spline"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_eval_deriv2_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline *", "spline"],
+    ["double", "x"],
+    ["gsl_interp_accel *", "acc"],
+    ["double *", "d2"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_eval_integ",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline *", "spline"],
+    ["double", "a"],
+    ["double", "b"],
+    ["gsl_interp_accel *", "acc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline_eval_integ_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline *", "spline"],
+    ["double", "a"],
+    ["double", "b"],
+    ["gsl_interp_accel *", "acc"],
+    ["double *", "result"]],
+  :desc=>""},
+ {:func_name=>"gsl_interp2d_alloc",
+  :func_type=>"gsl_interp2d *",
+  :args=>
+   [["const gsl_interp2d_type *", "T"],
+    ["const size_t", "xsize"],
+    ["const size_t", "ysize"]],
+  :desc=>
+   "This function returns a pointer to a newly allocated interpolation\n" +
+   "object of type T for xsize grid points in the x\n" +
+   "direction and ysize grid points in the y direction."},
+ {:func_name=>"gsl_interp2d_init",
+  :func_type=>"int",
+  :args=>
+   [["gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const size_t", "xsize"],
+    ["const size_t", "ysize"]],
+  :desc=>
+   "This function initializes the interpolation object interp for the\n" +
+   "data (xa,ya,za) where xa and ya are arrays of\n" +
+   "the x and y grid points of size xsize and ysize\n" +
+   "respectively, and za is an array of function values of size\n" +
+   "xsize*ysize.  The interpolation object (gsl_interp2d) does\n" +
+   "not save the data arrays xa, ya, and za and only stores the\n" +
+   "static state computed from the data. The xa and ya data arrays\n" +
+   "are always assumed to be strictly ordered, with increasing x,y values; \n" +
+   "the behavior for other arrangements is not defined."},
+ {:func_name=>"gsl_interp2d_free",
+  :func_type=>"void",
+  :args=>[["gsl_interp2d *", "interp"]],
+  :desc=>"This function frees the interpolation object interp."},
+ {:func_name=>"gsl_interp2d_set",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["double", "za[]"],
+    ["const size_t", "i"],
+    ["const size_t", "j"],
+    ["const double", "z"]],
+  :desc=>
+   "This function sets the value z_{ij} for grid point\n" +
+   "(i,j) of the array za to z."},
+ {:func_name=>"gsl_interp2d_get",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "za[]"],
+    ["const size_t", "i"],
+    ["const size_t", "j"]],
+  :desc=>
+   "This function returns the value z_{ij} for grid point\n" +
+   "(i,j) stored in the array za."},
+ {:func_name=>"gsl_interp2d_idx",
+  :func_type=>"size_t",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const size_t", "i"],
+    ["const size_t", "j"]],
+  :desc=>
+   "This function returns the index corresponding to the grid point\n" +
+   "(i,j). The index is given by j*xsize + i."},
+ {:func_name=>"gsl_interp2d_name",
+  :func_type=>"const char *",
+  :args=>[["const gsl_interp2d *", "interp"]],
+  :desc=>
+   "This function returns the name of the interpolation type used by interp.\n" +
+   "For example,\n" +
+   "\n" +
+   "printf (\"interp uses '%s' interpolation.\\n\", \n" +
+   "        gsl_interp2d_name (interp));\n" +
+   "\n" +
+   "would print something like,\n" +
+   "\n" +
+   "interp uses 'bilinear' interpolation."},
+ {:func_name=>"gsl_interp2d_min_size",
+  :func_type=>"unsigned int",
+  :args=>[["const gsl_interp2d *", "interp"]],
+  :desc=>
+   "These functions return the minimum number of points required by the\n" +
+   "interpolation object interp or interpolation type T.  For\n" +
+   "example, bicubic interpolation requires a minimum of 4 points."},
+ {:func_name=>"gsl_interp2d_type_min_size",
+  :func_type=>"unsigned int",
+  :args=>[["const gsl_interp2d_type *", "T"]],
+  :desc=>
+   "These functions return the minimum number of points required by the\n" +
+   "interpolation object interp or interpolation type T.  For\n" +
+   "example, bicubic interpolation requires a minimum of 4 points."},
+ {:func_name=>"gsl_interp2d_eval",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>
+   "These functions return the interpolated value of z for a given\n" +
+   "point (x,y), using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "z"]],
+  :desc=>
+   "These functions return the interpolated value of z for a given\n" +
+   "point (x,y), using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_extrap",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>
+   "These functions return the interpolated value of z for a given\n" +
+   "point (x,y), using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc. The functions perform no bounds checking, so\n" +
+   "when x is outside the range of xa or y\n" +
+   "is outside the range of ya, extrapolation is performed."},
+ {:func_name=>"gsl_interp2d_eval_extrap_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "z"]],
+  :desc=>
+   "These functions return the interpolated value of z for a given\n" +
+   "point (x,y), using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc. The functions perform no bounds checking, so\n" +
+   "when x is outside the range of xa or y\n" +
+   "is outside the range of ya, extrapolation is performed."},
+ {:func_name=>"gsl_interp2d_eval_deriv_x",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial z / \\partial x for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_deriv_x_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial z / \\partial x for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_deriv_y",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial z / \\partial y for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_deriv_y_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial z / \\partial y for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_deriv_xx",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial^2 z / \\partial x^2 for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_deriv_xx_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial^2 z / \\partial x^2 for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_deriv_yy",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial^2 z / \\partial y^2 for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_deriv_yy_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial^2 z / \\partial y^2 for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_deriv_xy",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial^2 z / \\partial x \\partial y for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_interp2d_eval_deriv_xy_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_interp2d *", "interp"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>
+   "These functions return the interpolated value d\n" +
+   "= \\partial^2 z / \\partial x \\partial y for a given point (x,y),\n" +
+   "using the interpolation object interp, data\n" +
+   "arrays xa, ya, and za and the accelerators xacc\n" +
+   "and yacc.  When x is outside the range of xa or y\n" +
+   "is outside the range of ya, the error code\n" +
+   "GSL_EDOM is returned."},
+ {:func_name=>"gsl_spline2d_alloc",
+  :func_type=>"gsl_spline2d *",
+  :args=>
+   [["const gsl_interp2d_type *", "T"],
+    ["size_t", "xsize"],
+    ["size_t", "ysize"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_init",
+  :func_type=>"int",
+  :args=>
+   [["gsl_spline2d *", "spline"],
+    ["const double", "xa[]"],
+    ["const double", "ya[]"],
+    ["const double", "za[]"],
+    ["size_t", "xsize"],
+    ["size_t", "ysize"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_free",
+  :func_type=>"void",
+  :args=>[["gsl_spline2d *", "spline"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_name",
+  :func_type=>"const char *",
+  :args=>[["const gsl_spline2d *", "spline"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_min_size",
+  :func_type=>"unsigned int",
+  :args=>[["const gsl_spline2d *", "spline"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "z"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_x",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_x_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_y",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_y_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_xx",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_xx_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_yy",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_yy_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_xy",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_eval_deriv_xy_e",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "x"],
+    ["const double", "y"],
+    ["gsl_interp_accel *", "xacc"],
+    ["gsl_interp_accel *", "yacc"],
+    ["double *", "d"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_set",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["double", "za[]"],
+    ["const size_t", "i"],
+    ["const size_t", "j"],
+    ["const double", "z"]],
+  :desc=>""},
+ {:func_name=>"gsl_spline2d_get",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spline2d *", "spline"],
+    ["const double", "za[]"],
+    ["const size_t", "i"],
+    ["const size_t", "j"]],
+  :desc=>
+   "This function returns the value z_{ij} for grid point\n" +
+   "(i,j) stored in the array za."}]