numo-gsl 0.1.0

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

@@ -0,0 +1,218 @@
+[{:func_name=>"gsl_spmatrix_alloc",
+  :func_type=>"gsl_spmatrix *",
+  :args=>[["const size_t", "n1"], ["const size_t", "n2"]],
+  :desc=>
+   "This function allocates a sparse matrix of size n1-by-n2 and\n" +
+   "initializes it to all zeros. If the size of the matrix is not known at allocation\n" +
+   "time, both n1 and n2 may be set to 1, and they will automatically\n" +
+   "grow as elements are added to the matrix. This function sets the\n" +
+   "matrix to the triplet representation, which is the easiest for adding\n" +
+   "and accessing matrix elements. This function tries to make a reasonable guess\n" +
+   "for the number of non-zero elements (nzmax) which will be added to the matrix by\n" +
+   "assuming a sparse density of 10\\%. The function\n" +
+   "gsl_spmatrix_alloc_nzmax can be used if this number is known more\n" +
+   "accurately. The workspace is of size O(nzmax)."},
+ {:func_name=>"gsl_spmatrix_alloc_nzmax",
+  :func_type=>"gsl_spmatrix *",
+  :args=>
+   [["const size_t", "n1"],
+    ["const size_t", "n2"],
+    ["const size_t", "nzmax"],
+    ["const size_t", "sptype"]],
+  :desc=>
+   "This function allocates a sparse matrix of size n1-by-n2 and\n" +
+   "initializes it to all zeros. If the size of the matrix is not known at allocation\n" +
+   "time, both n1 and n2 may be set to 1, and they will automatically\n" +
+   "grow as elements are added to the matrix. The parameter nzmax specifies\n" +
+   "the maximum number of non-zero elements which will be added to the matrix.\n" +
+   "It does not need to be precisely known in advance, since storage space will \n" +
+   "automatically grow using gsl_spmatrix_realloc if nzmax is not\n" +
+   "large enough. Accurate knowledge of this parameter reduces the number of\n" +
+   "reallocation calls required. The parameter sptype specifies the\n" +
+   "storage format of the sparse matrix. Possible values are\n" +
+   "The allocated gsl_spmatrix structure is of size O(nzmax)."},
+ {:func_name=>"gsl_spmatrix_realloc",
+  :func_type=>"int",
+  :args=>[["const size_t", "nzmax"], ["gsl_spmatrix *", "m"]],
+  :desc=>
+   "This function reallocates the storage space for m to accomodate\n" +
+   "nzmax non-zero elements. It is typically called internally by\n" +
+   "gsl_spmatrix_set if the user wants to add more elements to the\n" +
+   "sparse matrix than the previously specified nzmax."},
+ {:func_name=>"gsl_spmatrix_free",
+  :func_type=>"void",
+  :args=>[["gsl_spmatrix *", "m"]],
+  :desc=>
+   "This function frees the memory associated with the sparse matrix m."},
+ {:func_name=>"gsl_spmatrix_get",
+  :func_type=>"double",
+  :args=>
+   [["const gsl_spmatrix *", "m"],
+    ["const size_t", "i"],
+    ["const size_t", "j"]],
+  :desc=>
+   "This function returns element (i,j) of the matrix m.\n" +
+   "The matrix may be in triplet or compressed format."},
+ {:func_name=>"gsl_spmatrix_set",
+  :func_type=>"int",
+  :args=>
+   [["gsl_spmatrix *", "m"],
+    ["const size_t", "i"],
+    ["const size_t", "j"],
+    ["const double", "x"]],
+  :desc=>
+   "This function sets element (i,j) of the matrix m to\n" +
+   "the value x. The matrix must be in triplet representation."},
+ {:func_name=>"gsl_spmatrix_set_zero",
+  :func_type=>"int",
+  :args=>[["gsl_spmatrix *", "m"]],
+  :desc=>
+   "This function sets (or resets) all the elements of the matrix m to zero."},
+ {:func_name=>"gsl_spmatrix_memcpy",
+  :func_type=>"int",
+  :args=>[["gsl_spmatrix *", "dest"], ["const gsl_spmatrix *", "src"]],
+  :desc=>
+   "This function copies the elements of the sparse matrix src into\n" +
+   "dest. The two matrices must have the same dimensions and be in the\n" +
+   "same storage format."},
+ {:func_name=>"gsl_spmatrix_transpose_memcpy",
+  :func_type=>"int",
+  :args=>[["gsl_spmatrix *", "dest"], ["const gsl_spmatrix *", "src"]],
+  :desc=>
+   "This function copies the transpose of the sparse matrix src into\n" +
+   "dest. The dimensions of dest must match the transpose of the\n" +
+   "matrix src. Also, both matrices must use the same sparse storage\n" +
+   "format."},
+ {:func_name=>"gsl_spmatrix_add",
+  :func_type=>"int",
+  :args=>
+   [["gsl_spmatrix *", "c"],
+    ["const gsl_spmatrix *", "a"],
+    ["const gsl_spmatrix *", "b"]],
+  :desc=>
+   "This function computes the sum c = a + b. The three matrices must\n" +
+   "have the same dimensions and be stored in compressed column format."},
+ {:func_name=>"gsl_spmatrix_scale",
+  :func_type=>"int",
+  :args=>[["gsl_spmatrix *", "m"], ["const double", "x"]],
+  :desc=>
+   "This function scales all elements of the matrix m by the constant\n" +
+   "factor x. The result m(i,j) \\leftarrow x m(i,j) is stored in m."},
+ {:func_name=>"gsl_spmatrix_nnz",
+  :func_type=>"size_t",
+  :args=>[["const gsl_spmatrix *", "m"]],
+  :desc=>"This function returns the number of non-zero elements in m."},
+ {:func_name=>"gsl_spmatrix_equal",
+  :func_type=>"int",
+  :args=>[["const gsl_spmatrix *", "a"], ["const gsl_spmatrix *", "b"]],
+  :desc=>
+   "This function returns 1 if the matrices a and b are equal (by comparison of\n" +
+   "element values) and 0 otherwise. The matrices a and b must be either\n" +
+   "both triplet format or both compressed format for comparison."},
+ {:func_name=>"gsl_spmatrix_minmax",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spmatrix *", "m"],
+    ["double *", "min_out"],
+    ["double *", "max_out"]],
+  :desc=>
+   "This function returns the minimum and maximum elements of the matrix\n" +
+   "m, storing them in min_out and max_out, and searching\n" +
+   "only the non-zero values."},
+ {:func_name=>"gsl_spmatrix_compcol",
+  :func_type=>"gsl_spmatrix *",
+  :args=>[["const gsl_spmatrix *", "T"]],
+  :desc=>
+   "This function creates a sparse matrix in compressed column format\n" +
+   "from the input sparse matrix T which must be in triplet format.\n" +
+   "A pointer to a newly allocated matrix is returned. The calling function\n" +
+   "should free the newly allocated matrix when it is no longer needed."},
+ {:func_name=>"gsl_spmatrix_d2sp",
+  :func_type=>"int",
+  :args=>[["gsl_spmatrix *", "S"], ["const gsl_matrix *", "A"]],
+  :desc=>
+   "This function converts the dense matrix A into sparse triplet format\n" +
+   "and stores the result in S."},
+ {:func_name=>"gsl_spmatrix_sp2d",
+  :func_type=>"int",
+  :args=>[["gsl_matrix *", "A"], ["const gsl_spmatrix *", "S"]],
+  :desc=>
+   "This function converts the sparse matrix S into a dense matrix and\n" +
+   "stores the result in A. S must be in triplet format."},
+ {:func_name=>"gsl_spblas_dgemv",
+  :func_type=>"int",
+  :args=>
+   [["const CBLAS_TRANSPOSE_t", "TransA"],
+    ["const double", "alpha"],
+    ["const gsl_spmatrix *", "A"],
+    ["const gsl_vector *", "x"],
+    ["const double", "beta"],
+    ["gsl_vector *", "y"]],
+  :desc=>
+   "This function computes the matrix-vector product and sum\n" +
+   "y \\leftarrow \\alpha op(A) x + \\beta y, where\n" +
+   "op(A) = A, A^T for TransA = CblasNoTrans,\n" +
+   "CblasTrans. In-place computations are not supported, so\n" +
+   "x and y must be distinct vectors.\n" +
+   "The matrix A may be in triplet or compressed format."},
+ {:func_name=>"gsl_spblas_dgemm",
+  :func_type=>"int",
+  :args=>
+   [["const double", "alpha"],
+    ["const gsl_spmatrix *", "A"],
+    ["const gsl_spmatrix *", "B"],
+    ["gsl_spmatrix *", "C"]],
+  :desc=>
+   "This function computes the sparse matrix-matrix product\n" +
+   "C = \\alpha A B. The matrices must be in compressed format."},
+ {:func_name=>"gsl_splinalg_itersolve_alloc",
+  :func_type=>"gsl_splinalg_itersolve *",
+  :args=>
+   [["const gsl_splinalg_itersolve_type *", "T"],
+    ["const size_t", "n"],
+    ["const size_t", "m"]],
+  :desc=>
+   "This function allocates a workspace for the iterative solution of\n" +
+   "n-by-n sparse matrix systems. The iterative solver type\n" +
+   "is specified by T. The argument m specifies the size\n" +
+   "of the solution candidate subspace {\\cal K}_m. The dimension\n" +
+   "m may be set to 0 in which case a reasonable default value is used."},
+ {:func_name=>"gsl_splinalg_itersolve_free",
+  :func_type=>"void",
+  :args=>[["gsl_splinalg_itersolve *", "w"]],
+  :desc=>"This function frees the memory associated with the workspace w."},
+ {:func_name=>"gsl_splinalg_itersolve_name",
+  :func_type=>"const char *",
+  :args=>[["const gsl_splinalg_itersolve *", "w"]],
+  :desc=>"This function returns a string pointer to the name of the solver."},
+ {:func_name=>"gsl_splinalg_itersolve_iterate",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_spmatrix *", "A"],
+    ["const gsl_vector *", "b"],
+    ["const double", "tol"],
+    ["gsl_vector *", "x"],
+    ["gsl_splinalg_itersolve *", "w"]],
+  :desc=>
+   "This function performs one iteration of the iterative method for\n" +
+   "the sparse linear system specfied by the matrix A, right hand\n" +
+   "side vector b and solution vector x. On input, x\n" +
+   "must be set to an initial guess for the solution. On output,\n" +
+   "x is updated to give the current solution estimate. The\n" +
+   "parameter tol specifies the relative tolerance between the residual\n" +
+   "norm and norm of b in order to check for convergence.\n" +
+   "When the following condition is satisfied:\n" +
+   "|| A x - b || <= tol * || b ||\n" +
+   "the method has converged, the function returns GSL_SUCCESS and\n" +
+   "the final solution is provided in x. Otherwise, the function\n" +
+   "returns GSL_CONTINUE to signal that more iterations are\n" +
+   "required. Here, || \\cdot || represents the Euclidean norm.\n" +
+   "The input matrix A may be in triplet or compressed column\n" +
+   "format."},
+ {:func_name=>"gsl_splinalg_itersolve_normr",
+  :func_type=>"double",
+  :args=>[["const gsl_splinalg_itersolve *", "w"]],
+  :desc=>
+   "This function returns the current residual norm\n" +
+   "||r|| = ||A x - b||, which is updated after each call to\n" +
+   "gsl_splinalg_itersolve_iterate."}]

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

@@ -0,0 +1,70 @@
+require_relative "../gen/erbpp_gsl"
+
+class DefSpMatrix < DefGslClass
+  def lookup(h)
+    case h
+    when FM(name:/_free$/);                     false
+    when FM(name:/_alloc$/);                    false
+    when FM(name:/_alloc_nzmax$/);              "spmatrix_new"
+
+    when FM(name:/_sp2d$/);                     "spmatrix_sp2d"
+    when FM(name:/_d2sp$/);                     "spmatrix_d2sp"
+
+    when FM(tp,tp,tp,name:/_add$/);             "spmatrix_add"
+    when FM(tp,*[szt]*2,type:"double");         "c_DFloat_f_SZ_x2"
+    when FM(tp,*[szt]*2,"double");              "c_self_f_SZ_x2_DFloat"
+    when FM(szt,tp); h[:postpose]=true;         "c_self_f_sizet"
+    when FM(tp,"double");                       "c_self_f_double"
+    when FM(tp,*["double *"]*2);                "c_double_x2_f_void"
+    when FM(tp,type:tp);                        "c_other_f_void"
+    when FM(tp,tp,type:"int");                  "c_self_f_other"
+    when FM(tp,type:"size_t");                  "c_sizet_f_void"
+    when FM(tp,type:"int");                     "c_self_f_void"
+    end
+  end
+end
+
+
+class DefSpBlas < DefGslModule
+  def lookup(h)
+    case h
+    when FM(name:/_dgemv$/);    "spblas_dgemv"
+    when FM(name:/_dgemm$/);    "spblas_dgemm"
+    end
+  end
+end
+
+
+class DefIterSolve < DefGslClass
+
+  def lookup(h)
+    case h
+    when FM(name:/_free$/);              false
+    when FM(name:/_itersolve_alloc$/);   "itersolve_new"
+    when FM(name:/_itersolve_iterate$/); "itersolve_iterate"
+    when FM(tp, type:str);               "c_str_f_void"
+    when FM(tp, type:dbl);               "c_double_f_void"
+    end
+  end
+
+  ITERSOLVE_TYPES = ErbppGsl.read_type.select{|s|
+    /gsl_splinalg_itersolve_/ =~ s
+  }
+
+  def check_func(h)
+    if t = lookup(h)
+      m = h[:func_name].sub(/^gsl_splinalg_itersolve_/,"")
+      DefMethod.new(self, t, name:m, **h)
+      if /_alloc$/ =~ h[:func_name]
+        t = "itersolve_type_new"
+        ITERSOLVE_TYPES.each do |st|
+          DefSubclassNew.new(self, t, st, **h)
+        end
+      end
+      return true
+    end
+    $stderr.puts "skip #{h[:func_name]}"
+    false
+  end
+
+end

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