numo-gsl 0.1.0

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

@@ -0,0 +1,67 @@
+require_relative "../gen/erbpp_gsl"
+
+class DefInterp < DefGslClass
+  include ErbppGsl
+
+  types = ErbppGsl.read_type
+  INTERP_TYPES = types.select{|s| /gsl_interp_/ =~ s}
+  INTERP2D_TYPES = types.select{|s| /gsl_interp2d_/ =~ s}
+
+  def lookup(h)
+    dblbk = [dbl, /\[\]$/]
+    case h
+    when FM(name:/_free$/);                     false
+    when FM(tp,*[dblbk]*3,szt,szt,name:/_init$/); "interp2d_new"
+    when FM(tp,*[dblbk]*2,szt,name:/_init$/);     "interp_new"
+    when FM(name:"gsl_interp_bsearch");         "interp_bsearch"
+    when FM(tp, type:str);                      "c_str_f_void"
+    when FM(tp, type:uint);                     "c_uint_f_void"
+    when FM(tp, dbl,      /accel/,   type:dbl); "spline_eval"
+    when FM(tp,*[dbl]*2,  /accel/,   type:dbl); "spline_integ"
+    when FM(tp,*[dbl]*2,*[/accel/]*2,type:dbl); "spline2d_eval"
+
+    when FM(name:"gsl_interp_accel_alloc");     "c_new_void"
+    when FM(tp);                                "c_self_f_void"
+    end
+  end
+
+  def check_func(h)
+    if t = lookup(h)
+      m = h[:func_name].sub(/^gsl_[^_]+_(accel_)?/,"")
+      DefMethod.new(self, t, name:m, **h)
+      def_type_new(h)
+      return true
+    end
+    $stderr.puts "skip #{h[:func_name]}"
+    false
+  end
+
+  def def_type_new(h)
+    case h[:func_name]
+    when "gsl_interp_init"
+      t = "interp_type_new"
+      INTERP_TYPES.each do |v|
+        st = v.sub(/^gsl_interp_/,"")
+        DefSubclassNew.new(self, t, v, st, **h)
+      end
+    when "gsl_spline_init"
+      t = "interp_type_new"
+      INTERP_TYPES.each do |v|
+        st = v.sub(/^gsl_interp_/,"")
+        DefSubclassNew.new(self, t, v, st, **h)
+      end
+    when "gsl_interp2d_init"
+      t = "interp2d_type_new"
+      INTERP2D_TYPES.each do |v|
+        st = v.sub(/^gsl_interp2d_/,"")
+        DefSubclassNew.new(self, t, v, st, **h)
+      end
+    when "gsl_spline2d_init"
+      t = "interp2d_type_new"
+      INTERP2D_TYPES.each do |v|
+        st = v.sub(/^gsl_interp2d_/,"")
+        DefSubclassNew.new(self, t, v, st, **h)
+      end
+    end
+  end
+end

data/ext/numo/gsl/interp/tmpl/interp2d_new.c

@@ -0,0 +1,36 @@
+<%
+set name: "new"
+set singleton: true
+set alloc_func: func_name.sub(/_init$/,"_alloc")
+%>
+/*
+  :nodoc:
+ */
+static VALUE
+<%=c_func(:nodef)%>(VALUE self, const gsl_interp2d_type *t, VALUE v1, VALUE v2, VALUE v3)
+{
+    double *p1, *p2, *p3;
+    size_t nx, ny;
+    narray_t *na;
+    <%=struct%> *w;
+
+    v1 = cast_1d_contiguous(v1, cDF);
+    v2 = cast_1d_contiguous(v2, cDF);
+    v3 = cast_2d_contiguous(v3, cDF);
+    nx = RNARRAY_SIZE(v1);
+    ny = RNARRAY_SIZE(v2);
+    GetNArray(v3,na);
+    if (na->shape[1] != nx || na->shape[0] != ny) {
+        rb_raise(nary_eShapeError,"za.shape should be [ya.size,xa.size]");
+    }
+    w  = <%=alloc_func%>(t, nx, ny);
+    p1 = (double*)na_get_pointer_for_read(v1);
+    p2 = (double*)na_get_pointer_for_read(v2);
+    p3 = (double*)na_get_pointer_for_read(v3);
+    <%=func_name%>(w, p1, p2, p3, nx, ny);
+    RB_GC_GUARD(v1);
+    RB_GC_GUARD(v2);
+    RB_GC_GUARD(v3);
+
+    return TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, (void*)w);
+}

data/ext/numo/gsl/interp/tmpl/interp2d_type_new.c

@@ -0,0 +1,17 @@
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,<%=args[2][1]%>)
+  @param  [DFloat]  <%=args[0][1]%>
+  @param  [DFloat]  <%=args[1][1]%>
+  @param  [DFloat]  <%=args[2][1]%>
+
+  Generate an instance of <%=full_class_name%>::<%=subtype_class%> class,
+  a subclass of <%=full_class_name%> class with <%=subtype_var%> type.
+
+  <%= desc %>
+
+  */
+static VALUE
+<%=c_func(3)%>(VALUE self, VALUE v1, VALUE v2, VALUE v3)
+{
+    return <%=c_superclass_new%>(self, <%=subtype_var%>, v1, v2, v3);
+}

data/ext/numo/gsl/interp/tmpl/interp_bsearch.c

@@ -0,0 +1,57 @@
+<%
+set singleton: true
+%>
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>)
+  @param  [DFloat]   <%=args[0][1]%>
+  @param  [Float]    <%=args[0][1]%>
+
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,range)
+  @param  [DFloat]   <%=args[0][1]%>
+  @param  [Float]    <%=args[0][1]%>
+  @param  [Range]    range
+
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,<%=args[2][1]%>,<%=args[2][1]%>)
+  @param  [DFloat]   <%=args[0][1]%>
+  @param  [Float]    <%=args[1][1]%>
+  @param  [Integer]  <%=args[2][1]%>
+  @param  [Integer]  <%=args[3][1]%>
+
+  allocate instance of <%=class_name%> class.
+
+  <%= desc %>
+ */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE klass)
+{
+    double *p1;
+    size_t n1, lo=0, hi=0, idx;
+    VALUE  v1, v2, v3, v4;
+    long   beg, len;
+    double x;
+    int    nargs;
+
+    nargs = rb_scan_args(argc, argv, "22", &v1, &v2, &v3, &v4);
+    v1 = cast_1d_contiguous(v1, cDF);
+    n1 = RNARRAY_SIZE(v1);
+    x  = NUM2DBL(v2);
+    switch(nargs) {
+    case 4:
+        v3 = rb_range_new(v3,v4,0);
+    case 3:
+        if (rb_range_beg_len(v3, &beg, &len, n1, 2) != Qtrue) {
+            rb_raise(rb_eRangeError, "range error");
+        }
+        lo = beg;
+        hi = beg+len-1;
+        break;
+    case 2:
+        lo = 0;
+        hi = n1-1;
+    }
+    p1 = (double*)na_get_pointer_for_read(v1);
+    idx = <%=func_name%>(p1, x, lo, hi);
+    RB_GC_GUARD(v1);
+
+    return SIZET2NUM(idx);
+}

data/ext/numo/gsl/interp/tmpl/interp_new.c

@@ -0,0 +1,29 @@
+<%
+set name: "new"
+set singleton: true
+set alloc_func: func_name.sub(/_init$/,"_alloc")
+%>
+/*
+  :nodoc:
+ */
+static VALUE
+<%=c_func(:nodef)%>(VALUE self, const gsl_interp_type *t, VALUE v1, VALUE v2)
+{
+    <%=struct%> *w;
+    double *p1, *p2;
+    size_t n1, n2, sz;
+
+    v1 = cast_1d_contiguous(v1, cDF);
+    v2 = cast_1d_contiguous(v2, cDF);
+    n1 = RNARRAY_SIZE(v1);
+    n2 = RNARRAY_SIZE(v2);
+    sz = (n1 < n2) ? n1 : n2;
+    w  = <%=alloc_func%>(t, sz);
+    p1 = (double*)na_get_pointer_for_read(v1);
+    p2 = (double*)na_get_pointer_for_read(v2);
+    <%=func_name%>(w, p1, p2, sz);
+    RB_GC_GUARD(v1);
+    RB_GC_GUARD(v2);
+
+    return TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, (void*)w);
+}

data/ext/numo/gsl/interp/tmpl/interp_type_new.c

@@ -0,0 +1,16 @@
+/*
+  @overload <%=name%>(<%=args[1][1]%>,<%=args[2][1]%>)
+  @param  [DFloat]  <%=args[1][1]%>
+  @param  [DFloat]  <%=args[2][1]%>
+
+  Generate an instance of <%=full_class_name%>::<%=subtype_class%> class,
+  a subclass of <%=full_class_name%> class with <%=subtype_var%> type.
+
+  <%= desc %>
+
+  */
+static VALUE
+<%=c_func(2)%>(VALUE self, VALUE v1, VALUE v2)
+{
+    return <%=c_superclass_new%>(self, <%=subtype_var%>, v1, v2);
+}

data/ext/numo/gsl/interp/tmpl/spline2d_eval.c

@@ -0,0 +1,61 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+    double   x, y, z;
+    void   **opts;
+    <%=struct%> *w;
+    gsl_interp_accel *a1, *a2;
+
+    opts = (void **)(lp->opt_ptr);
+    w  = (<%=struct%>*)(opts[0]);
+    a1 = (gsl_interp_accel*)(opts[1]);
+    a2 = (gsl_interp_accel*)(opts[2]);
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+
+    for (; i--; ) {
+        GET_DATA_STRIDE(p1,s1,double,x);
+        GET_DATA_STRIDE(p2,s2,double,y);
+        z = <%=func_name%>(w, x, y, a1, a2);
+        SET_DATA_STRIDE(p3,s3,double,z);
+    }
+}
+
+/*
+  @overload <%=name%>(<%=args[1][1]%>,<%=args[2][1]%>)
+  @param  [DFloat]    <%=args[1][1]%>
+  @param  [DFloat]    <%=args[2][1]%>
+  @return [DFloat]    result
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(2)%>(VALUE self, VALUE v1, VALUE v2)
+{
+    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = {iter_<%=c_func%>, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};
+    <%=struct%> *w;
+    gsl_interp_accel *a1, *a2;
+    void *opts[3];
+    VALUE vac1, vac2, v;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+    opts[0] = w;
+    vac1 = interp_accel_s_new(cInterpAccel);
+    TypedData_Get_Struct(vac1, gsl_interp_accel, &interp_accel_data_type, a1);
+    opts[1] = a1;
+    vac2 = interp_accel_s_new(cInterpAccel);
+    TypedData_Get_Struct(vac2, gsl_interp_accel, &interp_accel_data_type, a2);
+    opts[2] = a2;
+    v = na_ndloop3(&ndf, opts, 2, v1, v2);
+    RB_GC_GUARD(vac1);
+    RB_GC_GUARD(vac2);
+    return v;
+}

data/ext/numo/gsl/interp/tmpl/spline_eval.c

@@ -0,0 +1,55 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1, *p2;
+    ssize_t  s1, s2;
+    double   x, y;
+    void   **opts;
+    <%=struct%> *w;
+    gsl_interp_accel *a;
+
+    opts = (void **)(lp->opt_ptr);
+    w = (<%=struct%>*)(opts[0]);
+    a = (gsl_interp_accel*)(opts[1]);
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+
+    for (; i--; ) {
+        GET_DATA_STRIDE(p1,s1,double,x);
+        y = <%=func_name%>(w, x, a);
+        SET_DATA_STRIDE(p2,s2,double,y);
+    }
+}
+
+/*
+  @overload <%=name%>(<%=args[1][1]%>)
+  @param  [DFloat]    <%=args[1][1]%>
+  @return [DFloat]    result
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE v1)
+{
+    ndfunc_arg_in_t ain[1] = {{cDF,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = {iter_<%=c_func%>, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
+    <%=struct%> *w;
+    gsl_interp_accel *a;
+    void *opts[2];
+    VALUE vac, v;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+    opts[0] = w;
+
+    vac = interp_accel_s_new(cInterpAccel);
+    TypedData_Get_Struct(vac, gsl_interp_accel, &interp_accel_data_type, a);
+    opts[1] = a;
+
+    v = na_ndloop3(&ndf, opts, 1, v1);
+    RB_GC_GUARD(vac);
+    return v;
+}

data/ext/numo/gsl/interp/tmpl/spline_integ.c

@@ -0,0 +1,56 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+    double   x, y, z;
+    void   **opts;
+    <%=struct%> *w;
+    gsl_interp_accel *a;
+
+    opts = (void **)(lp->opt_ptr);
+    w = (<%=struct%>*)(opts[0]);
+    a = (gsl_interp_accel*)(opts[1]);
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+
+    for (; i--; ) {
+        GET_DATA_STRIDE(p1,s1,double,x);
+        GET_DATA_STRIDE(p2,s2,double,y);
+        z = <%=func_name%>(w, x, y, a);
+        SET_DATA_STRIDE(p3,s3,double,z);
+    }
+}
+
+/*
+  @overload <%=name%>(<%=args[1][1]%>,<%=args[2][1]%>)
+  @param  [DFloat]    <%=args[1][1]%>
+  @param  [DFloat]    <%=args[2][1]%>
+  @return [DFloat]    result
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(2)%>(VALUE self, VALUE v1, VALUE v2)
+{
+    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = {iter_<%=c_func%>, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};
+    <%=struct%> *w;
+    gsl_interp_accel *a;
+    void *opts[2];
+    VALUE vac, v;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+    opts[0] = w;
+    vac = interp_accel_s_new(cInterpAccel);
+    TypedData_Get_Struct(vac, gsl_interp_accel, &interp_accel_data_type, a);
+    opts[1] = a;
+    v = na_ndloop3(&ndf, opts, 2, v1, v2);
+    RB_GC_GUARD(vac);
+    return v;
+}

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

@@ -0,0 +1,9 @@
+["gsl_interp2d_bilinear",
+ "gsl_interp2d_bicubic",
+ "gsl_interp_linear",
+ "gsl_interp_polynomial",
+ "gsl_interp_cspline",
+ "gsl_interp_cspline_periodic",
+ "gsl_interp_akima",
+ "gsl_interp_akima_periodic",
+ "gsl_interp_steffen"]

data/ext/numo/gsl/multifit/depend

@@ -0,0 +1,17 @@
+COGEN=ruby erbpp_multifit.rb
+GENSRC=gsl_multifit.c
+GENDEPS=erbpp_multifit.rb ../gen/*.rb ../gen/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/multifit/erbpp_multifit.rb

@@ -0,0 +1,99 @@
+require_relative "../gen/erbpp_gsl"
+require "erbpp/line_number"
+require "pp"
+
+ErbppGsl.read_func_pattern(
+  [/^gsl_multifit_w?linear$/, mfit_list=[]],
+  [/^gsl_multifit_linear(_alloc|_free)$/, linws_list=[]],
+  [/^gsl_multifit_w?linear/,  linear_list=[]],
+  [/^gsl_multifit_nlinear/,   nlinear_list=[]],
+)
+
+class DefMultifit < DefGslModule
+  def lookup(h)
+    fn = h[:func_name].sub(/gsl_/,"")
+    return fn if File.exist?("tmpl/#{fn}.c")
+  end
+end
+
+class DefLinearWorkspace < DefGslClass
+  def lookup(h)
+    case h
+    when FM(szt,szt, name:/_alloc$/);   "c_new_sizet_x2"
+    end
+  end
+end
+
+class MultifitLinear < DefGslModuleFunction
+  def _mod_var
+    parent.module_var
+  end
+
+  def init_def
+    case func_name
+    when /_linear$/
+      super + "
+    #{struct_def("LinearResult",%w[c cov chisq])}"
+    else
+      super
+    end
+  end
+
+  def struct_def(cls,vars)
+    items = vars.map{|v| "\"#{v}\""}.join(",")
+    "/*
+      Document-class: Numo::GSL::Multifit::LinearResult
+      */
+    c#{cls} = rb_struct_define_under(#{_mod_var},\"#{cls}\",#{items},NULL);"
+  end
+end
+
+
+DefLib.new do
+  set erb_dir: %w[tmpl ../gen/tmpl]
+  set erb_suffix: ".c"
+
+  name = "Multifit"
+  set file_name: "gsl_#{name}.c"
+  set include_files: ["gsl/gsl_multifit.h"]
+  set lib_name: name.downcase
+  set ns_var: "mG"
+
+  DefMultifit.new(self) do
+    mname = "Multifit"
+    mbase = "multifit"
+    set name: mbase
+    set module_name: mname
+    set module_var: "m"+mname
+    set full_module_name: "Numo::GSL::"+mname
+
+    cname = "LinearWorkspace"
+    cbase = "multifit_linear_workspace"
+
+    DefLinearWorkspace.new(self) do
+      set name: cbase
+      set class_name: cname
+      set class_var: "c"+cname
+      set full_class_name: "Numo::GSL::#{mname}::"+cname
+      set struct: "gsl_#{cbase}"
+      set postpose: true
+      set ns_var: "m"+mname
+
+      undef_alloc_func
+      linws_list.each do |h|
+        check_func(h)
+      end
+
+      mfit_list.each do |h|
+        m = h[:func_name].sub(/^gsl_#{mbase}_/,"")
+        t = mbase+"_"+m
+        MultifitLinear.new(self, t, name:m, **h)
+      end
+    end
+
+    linear_list.each do |h|
+      check_func(h)
+    end
+  end
+
+end.write(ARGV[0])