numo-gsl 0.1.0

data/ext/numo/gsl/stats/parse_stats.rb

@@ -0,0 +1,63 @@
+require_relative "../gen/erbpp_gsl"
+
+class DefStats < DefModule
+  include ErbppGsl
+
+  def lookup(h)
+    dblbk = [dbl,/\[\]$/]
+    case h
+    when FM(name:"gsl_stats_spearman");         "stats_spearman"
+    when FM(name:"gsl_stats_minmax_index");     "stats_minmax_index"
+    when FM(name:"gsl_stats_minmax");           "stats_minmax"
+    when FM(name:/_(min|max)_index$/);          "stats_1a0p_index"
+    when FM(dblbk,szt,szt);                     "stats_1a0p"
+    when FM(dblbk,szt,szt,dbl);                 "stats_1a1p"
+    when FM(dblbk,szt,szt,dbl,dbl);             "stats_1a2p"
+    when FM(dblbk,szt,dblbk,szt,szt);           "stats_2a0p"
+    when FM(dblbk,szt,dblbk,szt,szt,dbl);       "stats_2a1p"
+    when FM(dblbk,szt,dblbk,szt,szt,dbl,dbl);   "stats_2a2p"
+    end
+  end
+
+  def check_func(h)
+    if t = lookup(h)
+      StatsBasic.new(self,t,**h)
+    else
+      $stderr.puts "skip #{h[:func_name]}"
+    end
+  end
+end
+
+
+class StatsBasic < DefModuleFunction
+  include FuncParser
+
+  PARAM_DESC = {}
+  PARAM_NAMES =
+    {
+     "double" => %w[csphase],
+     "int" => [], #%w[n m i j l kmax lmax nmin nmax size order_min order_max],
+     "size_t" => [], #%w[lmax],
+    }
+
+  def initialize(parent,tmpl,**h)
+    m = h[:func_name].sub(/^gsl_stats_/,"")
+    super(parent, tmpl, name:m, **h)
+    parse_args(h)
+    @varg = -1
+    set n_arg: -1
+    @preproc_code = ""
+  end
+
+  def argument_property(type,name)
+    case name
+    when "return";          {output:true, narray:true, pass: :return}
+    when /\[\]/;            {input:true,  narray:true, pass: :array}
+    when /^w?stride/,"n";   {}
+    else
+      if /(.+)\*$/ =~ type; {output:true, narray:true, pass: :return}
+      else;                 {input:true,  param:true}
+      end
+    end
+  end
+end

data/ext/numo/gsl/stats/tmpl/stats_1a0p.c

@@ -0,0 +1,37 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2;
+    ssize_t  s1;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
+
+    *(double*)p2 = <%=func_name%>((double*)p1,s1/sizeof(double),n);
+}
+
+/*
+  <%=desc%>
+  @overload <%=name%>(<%=method_args%>, axis:nil, keepdims:false)
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    VALUE reduce;
+    ndfunc_arg_in_t ain[2] = {{cDF,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT,
+                     2, 1, ain, aout };
+
+    if (argc<1) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=1)",argc);
+    }
+    reduce = nary_reduce_dimension(argc-1, argv+1, 1, argv, &ndf, 0);
+    return na_ndloop(&ndf, 2, *argv, reduce);
+}

data/ext/numo/gsl/stats/tmpl/stats_1a0p_index.c

@@ -0,0 +1,60 @@
+<% [64,32].each do |i| %>
+#define idx_t int<%=i%>_t
+static void
+iter_<%=c_func%>_index<%=i%>(na_loop_t *const lp)
+{
+    size_t   n, idx;
+    char    *d_ptr, *i_ptr, *o_ptr;
+    ssize_t  d_step, i_step;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, d_ptr, d_step);
+
+    idx = <%=func_name%>((double*)d_ptr,d_step/sizeof(double),n);
+
+    INIT_PTR(lp, 1, i_ptr, i_step);
+    o_ptr = NDL_PTR(lp,2);
+    *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
+}
+#undef idx_t
+<% end %>
+
+/*
+ <%=desc%>
+  @overload <%=name%>() => Integer
+  @overload <%=name%>(axis:nil, keepdims:false) => Integer or Numo::Int32/64
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in th*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    narray_t *na;
+    VALUE idx, reduce;
+    ndfunc_arg_in_t ain[3] = {{cDF,0},{Qnil,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{0,0,0}};
+    ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 3,1, ain,aout};
+
+    if (argc<1) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=1)",argc);
+    }
+    GetNArray(argv[0],na);
+    if (na->ndim==0) {
+        return INT2FIX(0);
+    }
+    if (na->size > (~(u_int32_t)0)) {
+        aout[0].type = numo_cInt64;
+        idx = rb_narray_new(numo_cInt64, na->ndim, na->shape);
+        ndf.func = iter_<%=c_func%>_index64;
+    } else {
+        aout[0].type = numo_cInt32;
+        idx = rb_narray_new(numo_cInt32, na->ndim, na->shape);
+        ndf.func = iter_<%=c_func%>_index32;
+    }
+    rb_funcall(idx, rb_intern("seq"), 0);
+
+    reduce = nary_reduce_dimension(argc-1, argv+1, 1, argv, &ndf, 0);
+
+    return na_ndloop(&ndf, 3, argv[0], idx, reduce);
+}

data/ext/numo/gsl/stats/tmpl/stats_1a1p.c

@@ -0,0 +1,41 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2;
+    ssize_t  s1;
+    double  *opt = (double*)(lp->opt_ptr);
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
+
+    *(double*)p2 = <%=func_name%>((double*)p1,s1/sizeof(double),n,opt[0]);
+}
+
+/*
+  <%=desc%>
+  @overload <%=name%>(<%=method_args%>, axis:nil, keepdims:false)
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in th*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    VALUE reduce;
+    double opt[1];
+    ndfunc_arg_in_t ain[2] = {{cDF,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT,
+                     2, 1, ain, aout };
+
+    if (argc<2) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=2)",argc);
+    }
+
+    opt[0] = NUM2DBL(argv[1]);
+
+    reduce = nary_reduce_dimension(argc-2, argv+2, 1, argv, &ndf, 0);
+    return na_ndloop3(&ndf, opt, 2, argv[0], reduce);
+}

data/ext/numo/gsl/stats/tmpl/stats_1a2p.c

@@ -0,0 +1,42 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2;
+    ssize_t  s1;
+    double  *opt = (double*)(lp->opt_ptr);
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
+
+    *(double*)p2 = <%=func_name%>((double*)p1,s1/sizeof(double),n,opt[0],opt[1]);
+}
+
+/*
+  <%=desc%>
+  @overload <%=name%>(<%=method_args%>, axis:nil, keepdims:false)
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in th*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    VALUE reduce;
+    double opt[2];
+    ndfunc_arg_in_t ain[2] = {{cDF,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT,
+                     2, 1, ain, aout };
+
+    if (argc<3) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=3)",argc);
+    }
+
+    opt[0] = NUM2DBL(argv[1]);
+    opt[1] = NUM2DBL(argv[2]);
+
+    reduce = nary_reduce_dimension(argc-3, argv+3, 1, argv, &ndf, 0);
+    return na_ndloop3(&ndf, opt, 2, argv[0], reduce);
+}

data/ext/numo/gsl/stats/tmpl/stats_2a0p.c

@@ -0,0 +1,39 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    p3 = lp->args[2].ptr + lp->args[2].iter[0].pos;
+
+    *(double*)p3 = <%=func_name%>((double*)p1,s1/sizeof(double),
+                                 (double*)p2,s2/sizeof(double),n);
+}
+
+/*
+  <%=desc%>
+  @overload <%=name%>(<%=method_args%>, axis:nil, keepdims:false)
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in th*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    VALUE reduce;
+    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT,
+                     3, 1, ain, aout };
+
+    if (argc<2) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=2)",argc);
+    }
+
+    reduce = nary_reduce_dimension(argc-2, argv+2, 2, argv, &ndf, 0);
+    return na_ndloop(&ndf, 3, argv[0], argv[1], reduce);
+}

data/ext/numo/gsl/stats/tmpl/stats_2a1p.c

@@ -0,0 +1,43 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2;
+    double  *opt = (double*)(lp->opt_ptr);
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    p3 = lp->args[2].ptr + lp->args[2].iter[0].pos;
+
+    *(double*)p3 = <%=func_name%>((double*)p1,s1/sizeof(double),
+                                 (double*)p2,s2/sizeof(double),n,opt[0]);
+}
+
+/*
+  <%=desc%>
+  @overload <%=name%>(<%=method_args%>, axis:nil, keepdims:false)
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in th*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    VALUE reduce;
+    double opt[1];
+    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT,
+                     3, 1, ain, aout };
+
+    if (argc<3) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=3)",argc);
+    }
+
+    opt[0] = NUM2DBL(argv[2]);
+
+    reduce = nary_reduce_dimension(argc-3, argv+3, 2, argv, &ndf, 0);
+    return na_ndloop3(&ndf, opt, 3, argv[0], argv[1], reduce);
+}

data/ext/numo/gsl/stats/tmpl/stats_2a2p.c

@@ -0,0 +1,44 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2;
+    double  *opt = (double*)(lp->opt_ptr);
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    p3 = lp->args[2].ptr + lp->args[2].iter[0].pos;
+
+    *(double*)p3 = <%=func_name%>((double*)p1,s1/sizeof(double),
+                                 (double*)p2,s2/sizeof(double),n,opt[0],opt[1]);
+}
+
+/*
+  <%=desc%>
+  @overload <%=name%>(<%=method_args%>, axis:nil, keepdims:false)
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in th*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    VALUE reduce;
+    double opt[2];
+    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT,
+                     3, 1, ain, aout };
+
+    if (argc<4) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=4)",argc);
+    }
+
+    opt[0] = NUM2DBL(argv[2]);
+    opt[1] = NUM2DBL(argv[3]);
+
+    reduce = nary_reduce_dimension(argc-4, argv+4, 2, argv, &ndf, 0);
+    return na_ndloop3(&ndf, opt, 3, argv[0], argv[1], reduce);
+}

data/ext/numo/gsl/stats/tmpl/stats_minmax.c

@@ -0,0 +1,37 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2, *p3;
+    ssize_t  s1;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
+    p3 = lp->args[2].ptr + lp->args[2].iter[0].pos;
+
+    <%=func_name%>((double*)p2,(double*)p3,(double*)p1,s1/sizeof(double),n);
+}
+
+/*
+  <%=desc%>
+  @overload <%=name%>(<%=method_args%>, axis:nil, keepdims:falsek)
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in th*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    VALUE reduce;
+    ndfunc_arg_in_t ain[2] = {{cDF,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[2] = {{cDF,0},{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT,
+                     2, 2, ain, aout };
+
+    if (argc<1) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=1)",argc);
+    }
+    reduce = nary_reduce_dimension(argc-1, argv+1, 1, argv, &ndf, 0);
+    return na_ndloop(&ndf, 2, argv[0], reduce);
+}

data/ext/numo/gsl/stats/tmpl/stats_minmax_index.c

@@ -0,0 +1,67 @@
+<% [64,32].each do |i| %>
+#define idx_t int<%=i%>_t
+static void
+iter_<%=c_func%>_index<%=i%>(na_loop_t *const lp)
+{
+    size_t   n;
+    size_t   min_idx, max_idx;
+    char    *d_ptr, *i_ptr;
+    ssize_t  d_step, i_step;
+    char    *min_ptr, *max_ptr;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, d_ptr, d_step);
+
+    <%=func_name%>(&min_idx,&max_idx,(double*)d_ptr,d_step/sizeof(double),n);
+
+    INIT_PTR(lp, 1, i_ptr, i_step);
+    min_ptr = NDL_PTR(lp,2);
+    max_ptr = NDL_PTR(lp,3);
+    *(idx_t*)min_ptr = *(idx_t*)(i_ptr + i_step * min_idx);
+    *(idx_t*)max_ptr = *(idx_t*)(i_ptr + i_step * max_idx);
+}
+#undef idx_t
+<% end %>
+
+/*
+ <%=desc%>
+  @overload <%=name%>() => [Integer, Integer]
+  @overload <%=name%>(axis:nil, keepdims:false) => 2-element array of Integer or Numo::Int32/64
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in th*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    narray_t *na;
+    VALUE idx, reduce;
+    ndfunc_arg_in_t ain[3] = {{cDF,0},{Qnil,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[2] = {{0,0,0},{0,0,0}};
+    ndfunc_t ndf = { 0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT,
+                     3,2, ain,aout };
+
+    if (argc<1) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=1)",argc);
+    }
+    GetNArray(argv[0],na);
+    if (na->ndim==0) {
+        return INT2FIX(0);
+    }
+    if (na->size > (~(u_int32_t)0)) {
+        aout[0].type = numo_cInt64;
+        aout[1].type = numo_cInt64;
+        idx = rb_narray_new(numo_cInt64, na->ndim, na->shape);
+        ndf.func = iter_<%=c_func%>_index64;
+    } else {
+        aout[0].type = numo_cInt32;
+        aout[1].type = numo_cInt32;
+        idx = rb_narray_new(numo_cInt32, na->ndim, na->shape);
+        ndf.func = iter_<%=c_func%>_index32;
+    }
+    rb_funcall(idx, rb_intern("seq"), 0);
+
+    reduce = nary_reduce_dimension(argc-1, argv+1, 1, argv, &ndf, 0);
+
+    return na_ndloop(&ndf, 3, argv[0], idx, reduce);
+}