numo-gsl-alt 0.1.3

data/ext/numo/gsl/spmatrix/tmpl/itersolve_iterate.c

@@ -0,0 +1,47 @@
+<%
+set singleton: true
+%>
+/*
+  @overload <%=name%>(a, b, tol, x)
+  @param  [Numo::GSL::SpMatrix] a (input sparse matrix)
+  @param  [Numo::DFloat]        b (input vector)
+  @param  [Float]               tol
+  @param  [Numo::DFloat]        x (input|output vector)
+  @return [Integer]             returns GSL::CONTINUE=-2 to signal that more iterations are required.
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(4)%>(VALUE self, VALUE vA, VALUE vb, VALUE vtol, VALUE vx)
+{
+    gsl_spmatrix *A;
+    gsl_vector *b, *x;
+    double tol;
+    gsl_splinalg_itersolve *w;
+    narray_t *na;
+    int status;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    TypedData_Get_Struct(vA, <%=sm_struct%>, &<%=sm_data_type_var%>, A);
+
+    vb = cast_1d_contiguous(vb, cDF);
+    ALLOCA_GSL_VECTOR_FROM_NARRAY_R(vb, b);
+    tol = NUM2DBL(vtol);
+
+    if (CLASS_OF(vx) != cDF) {
+        rb_raise(rb_eTypeError, "x should be Numo::DFloat");
+    }
+    GetNArray(vx,na);
+    if (NA_NDIM(na) != 1) {
+        rb_raise(nary_eShapeError, "x should be 1-dimensional array");
+    }
+    if (!RTEST(na_check_contiguous(vx))) {
+        rb_raise(nary_eOperationError, "x should be contiguous array");
+    }
+    ALLOCA_GSL_VECTOR_FROM_NARRAY_RW(vx, x);
+
+    status = <%=func_name%>(A, b, tol, x, w);
+    RB_GC_GUARD(vb);
+    return INT2FIX(status);
+}

data/ext/numo/gsl/spmatrix/tmpl/itersolve_new.c

@@ -0,0 +1,22 @@
+<%
+set name: "new"
+set singleton: true
+define_singleton_method(:define){nil}
+%>
+/*
+  :nodoc:
+ */
+static VALUE
+<%=c_func(:nodef)%>(VALUE self, const gsl_splinalg_itersolve_type *t, VALUE v1, VALUE v2)
+{
+    <%=struct%> *w;
+    size_t n, m;
+
+    n = NUM2SIZET(v1);
+    m = NUM2SIZET(v2);
+    w = <%=func_name%>(t, n, m);
+    if (!w) {
+        rb_raise(rb_eNoMemError,"fail to allocate struct");
+    }
+    return TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, (void*)w);
+}

data/ext/numo/gsl/spmatrix/tmpl/itersolve_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/spmatrix/tmpl/spblas_dgemm.c

@@ -0,0 +1,35 @@
+<%
+set singleton: true
+%>
+/*
+  @overload <%=name%>(alpha, a, b)
+  @param  [Float]               alpha
+  @param  [Numo::GSL::SpMatrix] a (sparse matrix)
+  @param  [Numo::GSL::SpMatrix] b (sparse matrix)
+  @return [Numo::DFloat]        result C = A B
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(3)%>(VALUE mod, VALUE valpha, VALUE va, VALUE vb)
+{
+    // C = A B
+    double alpha;
+    gsl_spmatrix *A;
+    gsl_spmatrix *B;
+    gsl_spmatrix *C;
+    VALUE vc;
+
+    alpha = NUM2DBL(valpha);
+    TypedData_Get_Struct(va, <%=struct%>, &<%=data_type_var%>, A);
+    TypedData_Get_Struct(vb, <%=struct%>, &<%=data_type_var%>, B);
+
+    C = gsl_spmatrix_alloc_nzmax(A->size1,B->size2,A->nzmax+B->nzmax,A->sptype);
+    vc = TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, C);
+
+    <%=func_name%>(alpha, A, B, C);
+
+    RB_GC_GUARD(va);
+    RB_GC_GUARD(vb);
+    return vc;
+}

data/ext/numo/gsl/spmatrix/tmpl/spblas_dgemv.c

@@ -0,0 +1,43 @@
+<%
+set singleton: true
+%>
+/*
+  @overload <%=name%>(trans_a, alpha, a, x, beta, y)
+  @param  [Integer]             trans_a = NO_TRANS | TRANS
+  @param  [Float]               alpha
+  @param  [Numo::GSL::SpMatrix] a (input sparse matrix)
+  @param  [Numo::DFloat]        x (input vector)
+  @param  [Float]               beta
+  @param  [Numo::DFloat]        y (input|output vector)
+  @return [Numo::DFloat]        result (or y)
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(6)%>(VALUE mod, VALUE vTransA, VALUE valpha, VALUE va, VALUE vx, VALUE vbeta, VALUE vy)
+{
+    // y = alpha A x + beta y
+    CBLAS_TRANSPOSE_t TransA;
+    double alpha;
+    gsl_spmatrix *A;
+    gsl_vector *x;
+    double beta;
+    gsl_vector *y;
+
+    TransA = NUM2INT(vTransA);
+    alpha = NUM2DBL(valpha);
+    beta = NUM2DBL(vbeta);
+    TypedData_Get_Struct(va, <%=struct%>, &<%=data_type_var%>, A);
+
+    vx = cast_1d_contiguous(vx, cDF);
+    ALLOCA_GSL_VECTOR_FROM_NARRAY_R(vx, x);
+    vy = cast_1d_contiguous(vy, cDF);
+    if (!TEST_INPLACE(vy)) {
+        vy = na_copy(vy);
+    }
+    ALLOCA_GSL_VECTOR_FROM_NARRAY_RW(vy, y);
+
+    <%=func_name%>(TransA, alpha, A, x, beta, y);
+    RB_GC_GUARD(vx);
+    return vy;
+}

data/ext/numo/gsl/spmatrix/tmpl/spmatrix_add.c

@@ -0,0 +1,22 @@
+/*
+  @overload <%=name%>(other)
+  @param  [<%=full_class_name%>]  other
+  @return [<%=full_class_name%>]  result = self + other
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE other)
+{
+    <%=struct%> *a, *b, *c;
+    VALUE result;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, a);
+    TypedData_Get_Struct(other, <%=struct%>, &<%=data_type_var%>, b);
+
+    c = gsl_spmatrix_alloc_nzmax(a->size1, a->size2, a->nzmax+b->nzmax, a->sptype);
+    result = TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, (void*)c);
+
+    <%=func_name%>(c,a,b);
+    return result;
+}

data/ext/numo/gsl/spmatrix/tmpl/spmatrix_d2sp.c

@@ -0,0 +1,28 @@
+<%
+set singleton: true
+%>
+/*
+  @overload <%=name%>(nary)
+  @param  [Numo::DFloat]          nary
+  @return [<%=full_class_name%>]  result
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(1)%>(VALUE klass, VALUE nary)
+{
+    <%=struct%> *s;
+    gsl_matrix *m;
+    narray_t *na;
+
+    nary = cast_2d_contiguous(nary,cDF);
+    GetNArray(nary,na);
+
+    ALLOCA_GSL_MATRIX_FROM_NARRAY_R(nary,m);
+    s = gsl_spmatrix_alloc(na->shape[0], na->shape[1]);
+
+    <%=func_name%>(s, m);
+
+    RB_GC_GUARD(nary);
+    return TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, (void*)s);
+}

data/ext/numo/gsl/spmatrix/tmpl/spmatrix_new.c

@@ -0,0 +1,40 @@
+<%
+set name: "new"
+set singleton: true
+%>
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,[<%=args[2][1]%>,<%=args[3][1]%>])
+  @param  [Integer]  <%=args[0][1]%>
+  @param  [Integer]  <%=args[1][1]%>
+  @param  [Ingeger]  <%=args[2][1]%>
+  @param  [Ingeger]  <%=args[3][1]%>   (default = GSL_SPMATRIX_TRIPLET)
+
+  <%= desc %>
+  */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE klass)
+{
+    <%=struct%> *w;
+    int narg;
+    size_t sptype = GSL_SPMATRIX_TRIPLET;
+    VALUE  n1, n2, v3, v4;
+
+    narg = rb_scan_args(argc,argv,"22",&n1,&n2,&v3,&v4);
+    switch(narg) {
+    case 4:
+        sptype = NUM2SIZET(v4);
+    case 3:
+        w = <%=func_name%>(NUM2SIZET(n1),NUM2SIZET(n2),NUM2SIZET(v3),sptype);
+        break;
+    case 2:
+        w = <%=func_name.sub(/_nzmax/,"")%>(NUM2SIZET(n1),NUM2SIZET(n2));
+        break;
+    default:
+        rb_raise(rb_eArgError,"invalid number of argument: %d for 2..4",argc);
+    }
+    if (!w) {
+        rb_raise(rb_eNoMemError,"fail to allocate struct");
+    }
+    return TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, (void*)w);
+}

data/ext/numo/gsl/spmatrix/tmpl/spmatrix_sp2d.c

@@ -0,0 +1,25 @@
+/*
+  @overload <%=name%>
+  @return [DFloat]  result
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    <%=struct%> *s;
+    gsl_matrix *m;
+    size_t shape[2];
+    VALUE result;
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, s);
+
+    shape[0] = s->size1;
+    shape[1] = s->size2;
+    result = rb_narray_new(cDF, 2, shape);
+
+    ALLOCA_GSL_MATRIX_FROM_NARRAY_W(result,m);
+
+    <%=func_name%>(m,s);
+    return result;
+}

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

@@ -0,0 +1 @@
+["gsl_splinalg_itersolve_gmres"]

data/ext/numo/gsl/stats/depend

@@ -0,0 +1,17 @@
+COGEN=ruby erbpp_stats.rb
+GENSRC=gsl_stats.c
+GENDEPS=erbpp_stats.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/stats/erbpp_stats.rb

@@ -0,0 +1,30 @@
+require_relative "../gen/erbpp_gsl"
+require_relative "parse_stats"
+
+ErbppGsl.read_func_pattern(
+ [/^gsl_stats_(\w+)$/, stats_list=[]]
+)
+
+DefLib.new(nil) do
+  set line_number: true
+  set erb_dir: %w[tmpl ../gen/tmpl]
+  set erb_suffix: ".c"
+  set ns_var: "mG"
+
+  name = "Stats"
+  set file_name: "gsl_#{name}.c"
+  set include_files: ["gsl/gsl_statistics.h"]
+  set lib_name: "stats"
+
+  DefStats.new(self) do
+    set name: "stats"
+    set module_name: "Stats"
+    set module_var: "mStats"
+    set full_module_name: "Numo::GSL::Stats"
+
+    stats_list.each do |h|
+      check_func(h)
+    end
+  end
+
+end.run

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

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