numo-gsl-alt 0.1.3

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);
+}

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

@@ -0,0 +1,46 @@
+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);
+}
+
+/*
+  <%=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, v, buf = 0;
+    narray_t *na;
+    double *opt;
+    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);
+    }
+
+    GetNArray(argv[0],na);
+    opt = ALLOCV_N(double,buf,na->size*2); // todo: get loop size
+    reduce = nary_reduce_dimension(argc-2, argv+2, 2, argv, &ndf, 0);
+    v = na_ndloop3(&ndf, opt, 3, argv[0], argv[1], reduce);
+    ALLOCV_END(buf);
+    return v;
+}

data/ext/numo/gsl/sys/const_2.4.rb

@@ -0,0 +1,20 @@
+[["GSL_IS_EVEN (n)",
+  "This macro is the opposite of :macro:`GSL_IS_ODD`. It evaluates to 1 if :data:`n` is even and 0 if :data:`n` is odd. The argument :data:`n` must be of integer type. "],
+ ["GSL_IS_ODD (n)",
+  "This macro evaluates to 1 if :data:`n` is odd and 0 if :data:`n` is even. The argument :data:`n` must be of integer type. "],
+ ["GSL_MAX (a, b)",
+  "This macro returns the maximum of :data:`a` and :data:`b`. It is defined as :code:`((a) > (b) ? (a):(b))`. "],
+ ["GSL_MIN (a, b)",
+  "This macro returns the minimum of :data:`a` and :data:`b`. It is defined as :code:`((a) < (b) ? (a):(b))`. "],
+ ["GSL_MODE_DEFAULT", nil],
+ ["GSL_NAN",
+  "This macro contains the IEEE representation of the Not-a-Number symbol, :code:`NaN`. It is computed from the ratio :code:`0.0/0.0`. "],
+ ["GSL_NEGINF",
+  "This macro contains the IEEE representation of negative infinity, -\\infty. It is computed from the expression :code:`-1.0/0.0`. "],
+ ["GSL_POSINF",
+  "This macro contains the IEEE representation of positive infinity, +\\infty. It is computed from the expression :code:`+1.0/0.0`. "],
+ ["GSL_PREC_APPROX", nil],
+ ["GSL_PREC_DOUBLE", nil],
+ ["GSL_PREC_SINGLE", nil],
+ ["GSL_SIGN (x)",
+  "This macro returns the sign of :data:`x`. It is defined as :code:`((x) >= 0 ? 1 : -1)`. Note that with this definition the sign of zero is positive (regardless of its IEEE sign bit). "]]

data/ext/numo/gsl/sys/const_2.5.rb

@@ -0,0 +1,20 @@
+[["GSL_IS_EVEN (n)",
+  "This macro is the opposite of :macro:`GSL_IS_ODD`. It evaluates to 1 if :data:`n` is even and 0 if :data:`n` is odd. The argument :data:`n` must be of integer type. "],
+ ["GSL_IS_ODD (n)",
+  "This macro evaluates to 1 if :data:`n` is odd and 0 if :data:`n` is even. The argument :data:`n` must be of integer type. "],
+ ["GSL_MAX (a, b)",
+  "This macro returns the maximum of :data:`a` and :data:`b`. It is defined as :code:`((a) > (b) ? (a):(b))`. "],
+ ["GSL_MIN (a, b)",
+  "This macro returns the minimum of :data:`a` and :data:`b`. It is defined as :code:`((a) < (b) ? (a):(b))`. "],
+ ["GSL_MODE_DEFAULT", nil],
+ ["GSL_NAN",
+  "This macro contains the IEEE representation of the Not-a-Number symbol, :code:`NaN`. It is computed from the ratio :code:`0.0/0.0`. "],
+ ["GSL_NEGINF",
+  "This macro contains the IEEE representation of negative infinity, -\\infty. It is computed from the expression :code:`-1.0/0.0`. "],
+ ["GSL_POSINF",
+  "This macro contains the IEEE representation of positive infinity, +\\infty. It is computed from the expression :code:`+1.0/0.0`. "],
+ ["GSL_PREC_APPROX", nil],
+ ["GSL_PREC_DOUBLE", nil],
+ ["GSL_PREC_SINGLE", nil],
+ ["GSL_SIGN (x)",
+  "This macro returns the sign of :data:`x`. It is defined as :code:`((x) >= 0 ? 1 : -1)`. Note that with this definition the sign of zero is positive (regardless of its IEEE sign bit). "]]

data/ext/numo/gsl/sys/const_2.6.rb

@@ -0,0 +1,20 @@
+[["GSL_IS_EVEN (n)",
+  "This macro is the opposite of :macro:`GSL_IS_ODD`. It evaluates to 1 if :data:`n` is even and 0 if :data:`n` is odd. The argument :data:`n` must be of integer type. "],
+ ["GSL_IS_ODD (n)",
+  "This macro evaluates to 1 if :data:`n` is odd and 0 if :data:`n` is even. The argument :data:`n` must be of integer type. "],
+ ["GSL_MAX (a, b)",
+  "This macro returns the maximum of :data:`a` and :data:`b`. It is defined as :code:`((a) > (b) ? (a):(b))`. "],
+ ["GSL_MIN (a, b)",
+  "This macro returns the minimum of :data:`a` and :data:`b`. It is defined as :code:`((a) < (b) ? (a):(b))`. "],
+ ["GSL_MODE_DEFAULT", nil],
+ ["GSL_NAN",
+  "This macro contains the IEEE representation of the Not-a-Number symbol, :code:`NaN`. It is computed from the ratio :code:`0.0/0.0`. "],
+ ["GSL_NEGINF",
+  "This macro contains the IEEE representation of negative infinity, -\\infty. It is computed from the expression :code:`-1.0/0.0`. "],
+ ["GSL_POSINF",
+  "This macro contains the IEEE representation of positive infinity, +\\infty. It is computed from the expression :code:`+1.0/0.0`. "],
+ ["GSL_PREC_APPROX", nil],
+ ["GSL_PREC_DOUBLE", nil],
+ ["GSL_PREC_SINGLE", nil],
+ ["GSL_SIGN (x)",
+  "This macro returns the sign of :data:`x`. It is defined as :code:`((x) >= 0 ? 1 : -1)`. Note that with this definition the sign of zero is positive (regardless of its IEEE sign bit). "]]

data/ext/numo/gsl/sys/const_def.rb

@@ -0,0 +1,21 @@
+[["GSL_MODE_DEFAULT", nil],
+ ["GSL_PREC_APPROX", nil],
+ ["GSL_PREC_DOUBLE", nil],
+ ["GSL_PREC_SINGLE", nil],
+ ["M_1_PI", "The reciprocal of pi, 1/\\pi "],
+ ["M_2_PI", "Twice the reciprocal of pi, 2/\\pi "],
+ ["M_2_SQRTPI", "Two divided by the square root of pi, 2/\\sqrt\\pi "],
+ ["M_E", "The base of exponentials, e "],
+ ["M_EULER", "Euler's constant, \\gamma "],
+ ["M_LN10", "The natural logarithm of ten, \\ln(10) "],
+ ["M_LN2", "The natural logarithm of two, \\ln(2) "],
+ ["M_LNPI", "The natural logarithm of pi, \\ln(\\pi) "],
+ ["M_LOG10E", "The base-10 logarithm of e, $\\log_{10}(e)$ \\log_10 (e) "],
+ ["M_LOG2E", "The base-2 logarithm of e, \\log_2 (e) "],
+ ["M_PI", "The constant pi, \\pi "],
+ ["M_PI_2", "Pi divided by two, \\pi/2 "],
+ ["M_PI_4", "Pi divided by four, \\pi/4 "],
+ ["M_SQRT1_2", "The square root of one-half, $\\sqrt{1/2}$ \\sqrt@{1/2@} "],
+ ["M_SQRT2", "The square root of two, \\sqrt 2 "],
+ ["M_SQRT3", "The square root of three, \\sqrt 3 "],
+ ["M_SQRTPI", "The square root of pi, \\sqrt\\pi "]]

data/ext/numo/gsl/sys/depend

@@ -0,0 +1,17 @@
+COGEN=ruby erbpp_sys.rb
+GENSRC=gsl_sys.c
+GENDEPS=erbpp_sys.rb *_def.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/sys/enum_def.rb

@@ -0,0 +1,75 @@
+[["GSL_EIGEN_SORT_VAL_ASC", 0, ""],
+ ["GSL_EIGEN_SORT_VAL_DESC", 1, ""],
+ ["GSL_EIGEN_SORT_ABS_ASC", 2, ""],
+ ["GSL_EIGEN_SORT_ABS_DESC", 3, ""],
+ ["GSL_SUCCESS", 0, ""],
+ ["GSL_FAILURE", -1, ""],
+ ["GSL_CONTINUE", -2, "iteration has not converged"],
+ ["GSL_EDOM", 1, "input domain error, e.g sqrt(-1)"],
+ ["GSL_ERANGE", 2, "output range error, e.g. exp(1e100)"],
+ ["GSL_EFAULT", 3, "invalid pointer"],
+ ["GSL_EINVAL", 4, "invalid argument supplied by user"],
+ ["GSL_EFAILED", 5, "generic failure"],
+ ["GSL_EFACTOR", 6, "factorization failed"],
+ ["GSL_ESANITY", 7, "sanity check failed - shouldn't happen"],
+ ["GSL_ENOMEM", 8, "malloc failed"],
+ ["GSL_EBADFUNC", 9, "problem with user-supplied function"],
+ ["GSL_ERUNAWAY", 10, "iterative process is out of control"],
+ ["GSL_EMAXITER", 11, "exceeded max number of iterations"],
+ ["GSL_EZERODIV", 12, "tried to divide by zero"],
+ ["GSL_EBADTOL", 13, "user specified an invalid tolerance"],
+ ["GSL_ETOL", 14, "failed to reach the specified tolerance"],
+ ["GSL_EUNDRFLW", 15, "underflow"],
+ ["GSL_EOVRFLW", 16, "overflow"],
+ ["GSL_ELOSS", 17, "loss of accuracy"],
+ ["GSL_EROUND", 18, "failed because of roundoff error"],
+ ["GSL_EBADLEN", 19, "matrix, vector lengths are not conformant"],
+ ["GSL_ENOTSQR", 20, "matrix not square"],
+ ["GSL_ESING", 21, "apparent singularity detected"],
+ ["GSL_EDIVERGE", 22, "integral or series is divergent"],
+ ["GSL_EUNSUP", 23, "requested feature is not supported by the hardware"],
+ ["GSL_EUNIMPL", 24, "requested feature not (yet) implemented"],
+ ["GSL_ECACHE", 25, "cache limit exceeded"],
+ ["GSL_ETABLE", 26, "table limit exceeded"],
+ ["GSL_ENOPROG", 27, "iteration is not making progress towards solution"],
+ ["GSL_ENOPROGJ", 28, "jacobian evaluations are not improving the solution"],
+ ["GSL_ETOLF", 29, "cannot reach the specified tolerance in F"],
+ ["GSL_ETOLX", 30, "cannot reach the specified tolerance in X"],
+ ["GSL_ETOLG", 31, "cannot reach the specified tolerance in gradient"],
+ ["GSL_EOF", 32, "end of file"],
+ ["GSL_MESSAGE_MASK_A", 1, ""],
+ ["GSL_MESSAGE_MASK_B", 2, ""],
+ ["GSL_MESSAGE_MASK_C", 4, ""],
+ ["GSL_MESSAGE_MASK_D", 8, ""],
+ ["GSL_MESSAGE_MASK_E", 16, ""],
+ ["GSL_MESSAGE_MASK_F", 32, ""],
+ ["GSL_MESSAGE_MASK_G", 64, ""],
+ ["GSL_MESSAGE_MASK_H", 128, ""],
+ ["GSL_IEEE_TYPE_NAN", 1, ""],
+ ["GSL_IEEE_TYPE_INF", 2, ""],
+ ["GSL_IEEE_TYPE_NORMAL", 3, ""],
+ ["GSL_IEEE_TYPE_DENORMAL", 4, ""],
+ ["GSL_IEEE_TYPE_ZERO", 5, ""],
+ ["GSL_IEEE_SINGLE_PRECISION", 1, ""],
+ ["GSL_IEEE_DOUBLE_PRECISION", 2, ""],
+ ["GSL_IEEE_EXTENDED_PRECISION", 3, ""],
+ ["GSL_IEEE_ROUND_TO_NEAREST", 1, ""],
+ ["GSL_IEEE_ROUND_DOWN", 2, ""],
+ ["GSL_IEEE_ROUND_UP", 3, ""],
+ ["GSL_IEEE_ROUND_TO_ZERO", 4, ""],
+ ["GSL_IEEE_MASK_INVALID", 1, ""],
+ ["GSL_IEEE_MASK_DENORMALIZED", 2, ""],
+ ["GSL_IEEE_MASK_DIVISION_BY_ZERO", 4, ""],
+ ["GSL_IEEE_MASK_OVERFLOW", 8, ""],
+ ["GSL_IEEE_MASK_UNDERFLOW", 16, ""],
+ ["GSL_IEEE_MASK_ALL", 31, ""],
+ ["GSL_IEEE_TRAP_INEXACT", 32, ""],
+ ["GSL_INTEG_GAUSS15", 1, "15 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS21", 2, "21 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS31", 3, "31 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS41", 4, "41 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS51", 5, "51 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS61", 6, "61 point Gauss-Kronrod rule"],
+ ["GSL_VEGAS_MODE_IMPORTANCE", 1, ""],
+ ["GSL_VEGAS_MODE_IMPORTANCE_ONLY", 0, ""],
+ ["GSL_VEGAS_MODE_STRATIFIED", -1, ""]]