numo-gsl 0.1.0

data/ext/numo/gsl/rng/tmpl/ran.c

@@ -0,0 +1,40 @@
+/*
+  @overload <%= name %>(<%@params.each{|x|%><%=x[0]%>,<%}%>[shape])
+  <% @params.each do |x|%>
+  @param  [<%=x[1]%>]  <%=x[0]%><% end %>
+  @param  [Array or Integer]  shape (optional) shape for result NArray
+  @return [<%=get(:ret_class)%>]  returns random number
+
+<%= desc %>
+
+ */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE vshape, vna;
+    size_t i, size;
+    int nargs;
+    <%=func_type%> *ptr;
+    <% @vn.each do |v|%>
+    VALUE <%=v%>;<% end %>
+    <% @vardef.each do |x|%>
+    <%=x%>;<% end %>
+    gsl_rng *r;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, r);
+
+    nargs = rb_scan_args(argc, argv, "<%=@params.size%>1" <%@vn.map{|v|%>, &<%=v%><%}%>, &vshape);
+    <% @varconv.each do |x|%><%=x%>
+    <% end %>
+    if (nargs == <%=@params.size%>) {
+        return rb_float_new(<%=func_name%>(r <%@an.map{|a|%>, <%=a%><%}%>));
+    } else {
+        vna = create_new_narray(<%=get(:func_type_var)%>,vshape);
+        ptr = (<%=func_type%>*)na_get_pointer_for_write(vna);
+        size = RNARRAY_SIZE(vna);
+        for (i=0; i<size; i++) {
+            ptr[i] = <%=func_name%>(r <%@an.map{|a|%>, <%=a%><%}%>);
+        }
+        return vna;
+    }
+}

data/ext/numo/gsl/rng/tmpl/ran_DFloat_f_DFloat.c

@@ -0,0 +1,28 @@
+/*
+  @overload <%=name%>(<%=args[2][1]%>)
+  @param  [DFloat]  <%=args[2][1]%>
+  @return [DFloat]  <%=args[3][1]%>
+
+<%= desc %>
+
+ */
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE valpha)
+{
+    VALUE   vtheta;
+    double *alpha, *theta;
+    narray_t *na;
+    gsl_rng *r;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, r);
+
+    valpha = cast_1d_contiguous(valpha, cDF);
+    GetNArray(valpha,na);
+    vtheta = rb_narray_new(cDF,na->ndim,na->shape);
+    theta = (double*)na_get_pointer_for_write(vtheta);
+    alpha = (double*)na_get_pointer_for_read(valpha);
+
+    <%=func_name%>(r, na->size, alpha, theta);
+    RB_GC_GUARD(valpha);
+    return vtheta;
+}

data/ext/numo/gsl/rng/tmpl/ran_DFloat_x2.c

@@ -0,0 +1,45 @@
+/*
+  @overload <%= name %>(<%@params.each{|x|%><%=x[0]%>,<%}%>[shape])
+  <% @params.each do |x|%>
+  @param  [<%=x[1]%>]  <%=x[0]%><% end %>
+  @param  [Array or Integer]  shape (optional) shape for result NArray
+  @return [<%=get(:ret_class)%>]  returns random number
+
+<%= desc %>
+
+ */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE vshape, vx, vy;
+    size_t i, size;
+    int nargs;
+    double x, y;
+    double *px, *py;
+    <% @vn.each do |v|%>
+    VALUE <%=v%>;<% end %>
+    <% @vardef.each do |x|%>
+    <%=x%>;<% end %>
+    gsl_rng *r;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, r);
+
+    nargs = rb_scan_args(argc, argv, "<%=@params.size%>1" <%@vn.map{|v|%>, &<%=v%><%}%>, &vshape);
+    <% @varconv.each do |x|%>
+    <%=x%><% end %>
+    if (nargs == <%=@params.size%>) {
+        <%=func_name%>(r <%@an.map{|a|%>, <%=a%><%}%>, &x, &y);
+        return rb_assoc_new(DBL2NUM(x),DBL2NUM(y));
+    } else {
+        vx = create_new_narray(cDF,vshape);
+        vy = create_new_narray(cDF,vshape);
+        px = (double*)na_get_pointer_for_write(vx);
+        py = (double*)na_get_pointer_for_write(vy);
+        size = RNARRAY_SIZE(vx);
+        for (i=0; i<size; i++) {
+            <%=func_name%>(r <%@an.map{|a|%>, <%=a%><%}%>, px, py);
+            px++; py++;
+        }
+        return rb_assoc_new(vx,vy);
+    }
+}

data/ext/numo/gsl/rng/tmpl/ran_DFloat_x3.c

@@ -0,0 +1,51 @@
+/*
+  @overload <%= name %>(<%@params.each{|x|%><%=x[0]%>,<%}%>[shape])
+  <% @params.each do |x|%>
+  @param  [<%=x[1]%>]  <%=x[0]%><% end %>
+  @param  [Array or Integer]  shape (optional) shape for result Numo::NArray
+  @return [Array]  returns array of [x,y,z], where x,y,z are Float or Numo::DFloat
+
+<%= desc %>
+
+ */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE vshape;
+    VALUE v[3];
+    size_t i, size;
+    int nargs;
+    double x, y, z;
+    double *px, *py, *pz;
+    <% @vn.each do |v|%>
+    VALUE <%=v%>;<% end %>
+    <% @vardef.each do |x|%>
+    <%=x%>;<% end %>
+    gsl_rng *r;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, r);
+
+    nargs = rb_scan_args(argc, argv, "<%=@params.size%>1" <%@vn.map{|v|%>, &<%=v%><%}%>, &vshape);
+    <% @varconv.each do |x|%>
+    <%=x%><% end %>
+    if (nargs == <%=@params.size%>) {
+        <%=func_name%>(r <%@an.map{|a|%>, <%=a%><%}%>, &x, &y, &z);
+        v[0] = DBL2NUM(x);
+        v[1] = DBL2NUM(y);
+        v[2] = DBL2NUM(z);
+        return rb_ary_new4(3,v);
+    } else {
+        v[0] = create_new_narray(cDF,vshape);
+        v[1] = create_new_narray(cDF,vshape);
+        v[2] = create_new_narray(cDF,vshape);
+        px = (double*)na_get_pointer_for_write(v[0]);
+        py = (double*)na_get_pointer_for_write(v[1]);
+        pz = (double*)na_get_pointer_for_write(v[2]);
+        size = RNARRAY_SIZE(v[0]);
+        for (i=0; i<size; i++) {
+            <%=func_name%>(r <%@an.map{|a|%>, <%=a%><%}%>, px, py, pz);
+            px++; py++; pz++;
+        }
+        return rb_ary_new4(3,v);
+    }
+}

data/ext/numo/gsl/rng/tmpl/ran_multinomial.c

@@ -0,0 +1,32 @@
+/*
+  @overload <%=name%>(<%=args[2][1]%>, <%=args[3][1]%>)
+  @param  [Integer] <%=args[2][1]%>
+  @param  [DFloat]  <%=args[3][1]%>
+  @return [UInt]    <%=args[4][1]%>
+
+<%= desc %>
+
+ */
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE vN, VALUE vp)
+{
+    VALUE vn;
+    double *p;
+    unsigned int *n;
+    unsigned int  N;
+    narray_t *na;
+    gsl_rng *r;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, r);
+
+    N = NUM2UINT(vN);
+    vp = cast_1d_contiguous(vp, cDF);
+    GetNArray(vp,na);
+    p = (double*)na_get_pointer_for_read(vp);
+    vn = rb_narray_new(cUInt,na->ndim,na->shape);
+    n = (unsigned int*)na_get_pointer_for_write(vn);
+
+    <%=func_name%>(r, na->size, N, p, n);
+    RB_GC_GUARD(vp);
+    return vn;
+}

data/ext/numo/gsl/rng/tmpl/rng_DFloat.c

@@ -0,0 +1,29 @@
+/*
+  @overload <%=name%>([shape])
+  @param  [Array or Integer]  shape (optional) shape for result NArray
+  @return [Float or DFloat]  returns random number
+
+  <%= desc %>
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE vshape, vna;
+    size_t i, size;
+    double *ptr;
+    <%=struct%> *r;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, r);
+
+    if (rb_scan_args(argc, argv, "01", &vshape) == 0) {
+        return rb_float_new(<%=func_name%>(r));
+    } else {
+        vna = create_new_narray(cDF,vshape);
+        ptr = (double*)na_get_pointer_for_write(vna);
+        size = RNARRAY_SIZE(vna);
+        for (i=0; i<size; i++) {
+            ptr[i] = <%=func_name%>(r);
+        }
+        return vna;
+    }
+}

data/ext/numo/gsl/rng/tmpl/rng_UInt.c

@@ -0,0 +1,44 @@
+/*
+  @overload <%=name%>(n,[shape])
+  @param  [Integer]  n
+  @param  [Array or Integer]  shape (optional) shape for result NArray
+  @return [Integer or UInt32/UInt64]  returns random number
+
+  <%= desc %>
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE vshape, vna, vn;
+    size_t i, size;
+    int nargs;
+    unsigned long n;
+    u_int32_t *p32;
+    u_int64_t *p64;
+    <%=struct%> *r;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, r);
+
+    nargs = rb_scan_args(argc, argv, "11", &vn, &vshape);
+    n = NUM2ULONG(vn);
+    if (nargs == 1) {
+        return ULONG2NUM(<%=func_name%>(r, n));
+    } else {
+        if (n > 4294967295ul) {
+            vna = create_new_narray(numo_cUInt64,vshape);
+            p64 = (u_int64_t*)na_get_pointer_for_write(vna);
+            size = RNARRAY_SIZE(vna);
+            for (i=0; i<size; i++) {
+                p64[i] = (u_int64_t)<%=func_name%>(r, n);
+            }
+        } else {
+            vna = create_new_narray(numo_cUInt32,vshape);
+            p32 = (u_int32_t*)na_get_pointer_for_write(vna);
+            size = RNARRAY_SIZE(vna);
+            for (i=0; i<size; i++) {
+                p32[i] = (u_int32_t)<%=func_name%>(r, n);
+            }
+        }
+        return vna;
+    }
+}

data/ext/numo/gsl/rng/tmpl/rng_alloc.c

@@ -0,0 +1,24 @@
+<%
+set name: "new"
+set singleton: true
+%>
+/*
+  :nodoc:
+ */
+static VALUE
+<%=c_func(:nodef)%>(int argc, VALUE *argv, VALUE self, const <%=type_struct%> *t)
+{
+    <%=struct%> *w;
+
+    if (argc > 1) {
+        rb_raise(rb_eArgError,"wrong number of arguments (given %d, expected 0..1)", argc);
+    }
+    w = <%=func_name%>(t);
+    if (!w) {
+        rb_raise(rb_eNoMemError,"fail to allocate struct");
+    }
+    if (argc == 1) {
+        gsl_rng_set(w, NUM2ULONG(argv[0]));
+    }
+    return TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, (void*)w);
+}

data/ext/numo/gsl/rng/tmpl/rng_type_new.c

@@ -0,0 +1,14 @@
+/*
+  @overload <%=name%>([seed])
+  @param [Integer]  seed  Random seed.
+
+  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(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    return <%=c_superclass_new%>(argc, argv, self, <%=subtype_var%>);
+}

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

@@ -0,0 +1,63 @@
+["gsl_rng_borosh13",
+ "gsl_rng_coveyou",
+ "gsl_rng_cmrg",
+ "gsl_rng_fishman18",
+ "gsl_rng_fishman20",
+ "gsl_rng_fishman2x",
+ "gsl_rng_gfsr4",
+ "gsl_rng_knuthran",
+ "gsl_rng_knuthran2",
+ "gsl_rng_knuthran2002",
+ "gsl_rng_lecuyer21",
+ "gsl_rng_minstd",
+ "gsl_rng_mrg",
+ "gsl_rng_mt19937",
+ "gsl_rng_mt19937_1999",
+ "gsl_rng_mt19937_1998",
+ "gsl_rng_r250",
+ "gsl_rng_ran0",
+ "gsl_rng_ran1",
+ "gsl_rng_ran2",
+ "gsl_rng_ran3",
+ "gsl_rng_rand",
+ "gsl_rng_rand48",
+ "gsl_rng_random128_bsd",
+ "gsl_rng_random128_glibc2",
+ "gsl_rng_random128_libc5",
+ "gsl_rng_random256_bsd",
+ "gsl_rng_random256_glibc2",
+ "gsl_rng_random256_libc5",
+ "gsl_rng_random32_bsd",
+ "gsl_rng_random32_glibc2",
+ "gsl_rng_random32_libc5",
+ "gsl_rng_random64_bsd",
+ "gsl_rng_random64_glibc2",
+ "gsl_rng_random64_libc5",
+ "gsl_rng_random8_bsd",
+ "gsl_rng_random8_glibc2",
+ "gsl_rng_random8_libc5",
+ "gsl_rng_random_bsd",
+ "gsl_rng_random_glibc2",
+ "gsl_rng_random_libc5",
+ "gsl_rng_randu",
+ "gsl_rng_ranf",
+ "gsl_rng_ranlux",
+ "gsl_rng_ranlux389",
+ "gsl_rng_ranlxd1",
+ "gsl_rng_ranlxd2",
+ "gsl_rng_ranlxs0",
+ "gsl_rng_ranlxs1",
+ "gsl_rng_ranlxs2",
+ "gsl_rng_ranmar",
+ "gsl_rng_slatec",
+ "gsl_rng_taus",
+ "gsl_rng_taus2",
+ "gsl_rng_taus113",
+ "gsl_rng_transputer",
+ "gsl_rng_tt800",
+ "gsl_rng_uni",
+ "gsl_rng_uni32",
+ "gsl_rng_vax",
+ "gsl_rng_waterman14",
+ "gsl_rng_zuf",
+ "gsl_rng_default"]

data/ext/numo/gsl/rstat/depend

@@ -0,0 +1,17 @@
+COGEN=ruby erbpp_rstat.rb
+GENSRC=gsl_rstat.c
+GENDEPS=erbpp_rstat.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/rstat/erbpp_rstat.rb

@@ -0,0 +1,64 @@
+require_relative "../gen/erbpp_gsl"
+require "erbpp/line_number"
+
+ErbppGsl.read_func_pattern(
+  [/^gsl_rstat_quantile_(\w+)$/,rquantile_list=[]],
+  [/^gsl_rstat_(\w+)$/,         rstat_list=[]],
+)
+
+class DefRstat < DefGslClass
+  def lookup(h)
+    case h
+    when FM(name:/_free$/);             false
+    when FM(dbl, name:/_alloc$/);       "c_new_double"
+    when FM("", name:/_alloc$/);        "c_new_void"
+
+    when FM(tp, type:dbl);              "c_double_f_void"
+    when FM(tp, type:szt);              "c_sizet_f_void"
+    when FM(tp, type:int);              "c_void_f_void"
+    when FM(dbl,tp); h[:postpose]=true; "c_self_f_DFloat"
+    end
+  end
+end
+
+DefLib.new do
+  set erb_dir: %w[tmpl ../gen/tmpl]
+  set erb_suffix: ".c"
+
+  name = "Rstat"
+  set file_name: "gsl_#{name}.c"
+  set include_files: ["gsl/gsl_rstat.h"]
+  set lib_name: name.downcase
+  set ns_var: "mG"
+
+  DefRstat.new(self) do
+    name = "Rstat"
+    set name: name.downcase
+    set class_name: name
+    set class_var: "c"+name
+    set full_class_name: "Numo::GSL::"+name
+    set struct: "gsl_rstat_workspace"
+
+    undef_alloc_func
+    rstat_list.each do |h|
+      check_func(h)
+    end
+    def_alias("size", "n")
+    def_alias("length", "n")
+  end
+
+  DefRstat.new(self) do
+    name = "Quantile"
+    set name: "rstat_"+name.downcase
+    set class_name: name
+    set class_var: "c"+name
+    set full_class_name: "Numo::GSL::Rstat::"+name
+    set struct: "gsl_rstat_quantile_workspace"
+    set ns_var: "cRstat"
+
+    undef_alloc_func
+    rquantile_list.each do |h|
+      check_func(h)
+    end
+  end
+end.run