numo-gsl-alt 0.1.3

data/ext/numo/gsl/multilarge/func_2.6.rb

@@ -0,0 +1,216 @@
+[{:func_name=>"gsl_multilarge_linear_L_decomp",
+  :func_type=>"int",
+  :args=>[["gsl_matrix *", "L"], ["gsl_vector *", "tau"]],
+  :desc=>
+   "This function calculates the QR decomposition of the m-by-p\n" +
+   "regularization matrix L. L must have m \\ge p.  On output,\n" +
+   "the Householder scalars are stored in the vector tau of size p.\n" +
+   "These outputs will be used by gsl_multilarge_linear_wstdform2 to complete the\n" +
+   "transformation to standard form."},
+ {:func_name=>"gsl_multilarge_linear_accumulate",
+  :func_type=>"int",
+  :args=>
+   [["gsl_matrix *", "X"],
+    ["gsl_vector *", "y"],
+    ["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "This function accumulates the standard form block (X,y) into the\n" +
+   "current least squares system. X and y have the same number\n" +
+   "of rows, which can be arbitrary.  X must have p columns.\n" +
+   "For the TSQR method, X and y are destroyed on output.\n" +
+   "For the normal equations method, they are both unchanged."},
+ {:func_name=>"gsl_multilarge_linear_alloc",
+  :func_type=>"gsl_multilarge_linear_workspace *",
+  :args=>[["const gsl_multilarge_linear_type *", "T"], ["const size_t", "p"]],
+  :desc=>
+   "This function allocates a workspace for solving large linear least squares\n" +
+   "systems. The least squares matrix X has p columns,\n" +
+   "but may have any number of rows.\n" +
+   ".. type:: gsl_multilarge_linear_type"},
+ {:func_name=>"gsl_multilarge_linear_free",
+  :func_type=>"void",
+  :args=>[["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "This function frees the memory associated with the\n" + "workspace w."},
+ {:func_name=>"gsl_multilarge_linear_genform1",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_vector *", "L"],
+    ["const gsl_vector *", "cs"],
+    ["gsl_vector *", "c"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "After a regularized system has been solved with\n" +
+   "L = \\diag(\\l_0,\\l_1,...,\\l_{p-1}),\n" +
+   "this function backtransforms the standard form solution vector cs\n" +
+   "to recover the solution vector of the original problem c. The\n" +
+   "diagonal matrix elements l_i are provided in\n" +
+   "the vector L. It is allowed to have c = cs for an\n" +
+   "in-place transform."},
+ {:func_name=>"gsl_multilarge_linear_genform2",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_matrix *", "LQR"],
+    ["const gsl_vector *", "Ltau"],
+    ["const gsl_vector *", "cs"],
+    ["gsl_vector *", "c"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "After a regularized system has been solved with a regularization matrix L,\n" +
+   "specified by (LQR, Ltau), this function backtransforms the standard form\n" +
+   "solution cs\n" +
+   "to recover the solution vector of the original problem, which is stored in c,\n" +
+   "of length p."},
+ {:func_name=>"gsl_multilarge_linear_lcurve",
+  :func_type=>"int",
+  :args=>
+   [["gsl_vector *", "reg_param"],
+    ["gsl_vector *", "rho"],
+    ["gsl_vector *", "eta"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "This function computes the L-curve for a large least squares system\n" +
+   "after it has been fully accumulated into the workspace work.\n" +
+   "The output vectors reg_param, rho, and eta must all\n" +
+   "be the same size, and will contain the regularization parameters\n" +
+   "\\lambda_i, residual norms ||y - X c_i||, and solution\n" +
+   "norms || L c_i || which compose the L-curve, where c_i\n" +
+   "is the regularized solution vector corresponding to \\lambda_i.\n" +
+   "The user may determine the number of points on the L-curve by\n" +
+   "adjusting the size of these input arrays. For the TSQR method,\n" +
+   "the regularization parameters \\lambda_i are estimated from the\n" +
+   "singular values of the triangular R factor. For the normal\n" +
+   "equations method, they are estimated from the eigenvalues of the\n" +
+   "X^T X matrix."},
+ {:func_name=>"gsl_multilarge_linear_name",
+  :func_type=>"const char *",
+  :args=>[["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "This function returns a string pointer to the name\n" +
+   "of the multilarge solver."},
+ {:func_name=>"gsl_multilarge_linear_rcond",
+  :func_type=>"int",
+  :args=>
+   [["double *", "rcond"], ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "This function computes the reciprocal condition number, stored in\n" +
+   "rcond, of the least squares matrix after it has been accumulated\n" +
+   "into the workspace work. For the TSQR algorithm, this is\n" +
+   "accomplished by calculating the SVD of the R factor, which\n" +
+   "has the same singular values as the matrix X. For the normal\n" +
+   "equations method, this is done by computing the eigenvalues of\n" +
+   "X^T X, which could be inaccurate for ill-conditioned matrices\n" +
+   "X."},
+ {:func_name=>"gsl_multilarge_linear_reset",
+  :func_type=>"int",
+  :args=>[["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "This function resets the workspace w so\n" +
+   "it can begin to accumulate a new least squares\n" +
+   "system."},
+ {:func_name=>"gsl_multilarge_linear_solve",
+  :func_type=>"int",
+  :args=>
+   [["const double", "lambda"],
+    ["gsl_vector *", "c"],
+    ["double *", "rnorm"],
+    ["double *", "snorm"],
+    ["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "After all blocks (X_i,y_i) have been accumulated into\n" +
+   "the large least squares system, this function will compute\n" +
+   "the solution vector which is stored in c on output.\n" +
+   "The regularization parameter \\lambda is provided in\n" +
+   "lambda. On output, rnorm contains the residual norm\n" +
+   "||y - X c||_W and snorm contains the solution\n" +
+   "norm ||L c||."},
+ {:func_name=>"gsl_multilarge_linear_stdform1",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_vector *", "L"],
+    ["const gsl_matrix *", "X"],
+    ["const gsl_vector *", "y"],
+    ["gsl_matrix *", "Xs"],
+    ["gsl_vector *", "ys"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "These functions define a regularization matrix\n" +
+   "L = \\diag(l_0,l_1,...,l_{p-1}).\n" +
+   "The diagonal matrix element l_i is provided by the\n" +
+   "i-th element of the input vector L.\n" +
+   "The block (X, y) is converted to standard form and\n" +
+   "the parameters (\\tilde{X}, \\tilde{y}) are stored in Xs\n" +
+   "and ys on output.  Xs and ys have the same dimensions as\n" +
+   "X and y. Optional data weights may be supplied in the\n" +
+   "vector w. In order to apply this transformation,\n" +
+   "L^{-1} must exist and so none of the l_i\n" +
+   "may be zero. After the standard form system has been solved,\n" +
+   "use gsl_multilarge_linear_genform1 to recover the original solution vector.\n" +
+   "It is allowed to have X = Xs and y = ys for an\n" +
+   "in-place transform."},
+ {:func_name=>"gsl_multilarge_linear_stdform2",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_matrix *", "LQR"],
+    ["const gsl_vector *", "Ltau"],
+    ["const gsl_matrix *", "X"],
+    ["const gsl_vector *", "y"],
+    ["gsl_matrix *", "Xs"],
+    ["gsl_vector *", "ys"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "These functions convert a block of rows (X, y, w) to standard\n" +
+   "form (\\tilde{X}, \\tilde{y}) which are stored in Xs and ys\n" +
+   "respectively. X, y, and w must all have the same number of rows.\n" +
+   "The m-by-p regularization matrix L is specified by the inputs\n" +
+   "LQR and Ltau, which are outputs from gsl_multilarge_linear_L_decomp.\n" +
+   "Xs and ys have the same dimensions as X and y. After the\n" +
+   "standard form system has been solved, use gsl_multilarge_linear_genform2 to\n" +
+   "recover the original solution vector. Optional data weights may be supplied in the\n" +
+   "vector w, where W = \\diag(w)."},
+ {:func_name=>"gsl_multilarge_linear_wstdform1",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_vector *", "L"],
+    ["const gsl_matrix *", "X"],
+    ["const gsl_vector *", "w"],
+    ["const gsl_vector *", "y"],
+    ["gsl_matrix *", "Xs"],
+    ["gsl_vector *", "ys"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "These functions define a regularization matrix\n" +
+   "L = \\diag(l_0,l_1,...,l_{p-1}).\n" +
+   "The diagonal matrix element l_i is provided by the\n" +
+   "i-th element of the input vector L.\n" +
+   "The block (X, y) is converted to standard form and\n" +
+   "the parameters (\\tilde{X}, \\tilde{y}) are stored in Xs\n" +
+   "and ys on output.  Xs and ys have the same dimensions as\n" +
+   "X and y. Optional data weights may be supplied in the\n" +
+   "vector w. In order to apply this transformation,\n" +
+   "L^{-1} must exist and so none of the l_i\n" +
+   "may be zero. After the standard form system has been solved,\n" +
+   "use gsl_multilarge_linear_genform1 to recover the original solution vector.\n" +
+   "It is allowed to have X = Xs and y = ys for an\n" +
+   "in-place transform."},
+ {:func_name=>"gsl_multilarge_linear_wstdform2",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_matrix *", "LQR"],
+    ["const gsl_vector *", "Ltau"],
+    ["const gsl_matrix *", "X"],
+    ["const gsl_vector *", "w"],
+    ["const gsl_vector *", "y"],
+    ["gsl_matrix *", "Xs"],
+    ["gsl_vector *", "ys"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "These functions convert a block of rows (X, y, w) to standard\n" +
+   "form (\\tilde{X}, \\tilde{y}) which are stored in Xs and ys\n" +
+   "respectively. X, y, and w must all have the same number of rows.\n" +
+   "The m-by-p regularization matrix L is specified by the inputs\n" +
+   "LQR and Ltau, which are outputs from gsl_multilarge_linear_L_decomp.\n" +
+   "Xs and ys have the same dimensions as X and y. After the\n" +
+   "standard form system has been solved, use gsl_multilarge_linear_genform2 to\n" +
+   "recover the original solution vector. Optional data weights may be supplied in the\n" +
+   "vector w, where W = \\diag(w)."}]

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

@@ -0,0 +1,215 @@
+[{:func_name=>"gsl_multilarge_linear_L_decomp",
+  :func_type=>"int",
+  :args=>[["gsl_matrix *", "L"], ["gsl_vector *", "tau"]],
+  :desc=>
+   "This function calculates the QR decomposition of the m-by-p regularization matrix\n" +
+   "L. L must have m \\ge p.  On output,\n" +
+   "the Householder scalars are stored in the vector tau of size p.\n" +
+   "These outputs will be used by gsl_multilarge_linear_wstdform2 to complete the\n" +
+   "transformation to standard form."},
+ {:func_name=>"gsl_multilarge_linear_accumulate",
+  :func_type=>"int",
+  :args=>
+   [["gsl_matrix *", "X"],
+    ["gsl_vector *", "y"],
+    ["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "This function accumulates the standard form block (X,y) into the\n" +
+   "current least squares system. X and y have the same number\n" +
+   "of rows, which can be arbitrary.  X must have p columns.\n" +
+   "For the TSQR method, X and y are destroyed on output.\n" +
+   "For the normal equations method, they are both unchanged."},
+ {:func_name=>"gsl_multilarge_linear_alloc",
+  :func_type=>"gsl_multilarge_linear_workspace *",
+  :args=>[["const gsl_multilarge_linear_type *", "T"], ["const size_t", "p"]],
+  :desc=>
+   "This function allocates a workspace for solving large linear least squares\n" +
+   "systems. The least squares matrix X has p columns,\n" +
+   "but may have any number of rows. The parameter T specifies\n" +
+   "the method to be used for solving the large least squares system\n" +
+   "and may be selected from the following choices\n" +
+   "\n"},
+ {:func_name=>"gsl_multilarge_linear_free",
+  :func_type=>"void",
+  :args=>[["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "This function frees the memory associated with the\n" + "workspace w."},
+ {:func_name=>"gsl_multilarge_linear_genform1",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_vector *", "L"],
+    ["const gsl_vector *", "cs"],
+    ["gsl_vector *", "c"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "After a regularized system has been solved with\n" +
+   "L = diag(\\l_0,\\l_1,...,\\l_{p-1}),\n" +
+   "this function backtransforms the standard form solution vector cs\n" +
+   "to recover the solution vector of the original problem c. The\n" +
+   "diagonal matrix elements l_i are provided in\n" +
+   "the vector L. It is allowed to have c = cs for an\n" +
+   "in-place transform."},
+ {:func_name=>"gsl_multilarge_linear_genform2",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_matrix *", "LQR"],
+    ["const gsl_vector *", "Ltau"],
+    ["const gsl_vector *", "cs"],
+    ["gsl_vector *", "c"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "After a regularized system has been solved with a regularization matrix L,\n" +
+   "specified by (LQR,Ltau), this function backtransforms the standard form solution cs\n" +
+   "to recover the solution vector of the original problem, which is stored in c,\n" +
+   "of length p."},
+ {:func_name=>"gsl_multilarge_linear_lcurve",
+  :func_type=>"int",
+  :args=>
+   [["gsl_vector *", "reg_param"],
+    ["gsl_vector *", "rho"],
+    ["gsl_vector *", "eta"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "This function computes the L-curve for a large least squares system\n" +
+   "after it has been fully accumulated into the workspace work.\n" +
+   "The output vectors reg_param, rho, and eta must all\n" +
+   "be the same size, and will contain the regularization parameters\n" +
+   "\\lambda_i, residual norms ||y - X c_i||, and solution\n" +
+   "norms || L c_i || which compose the L-curve, where c_i\n" +
+   "is the regularized solution vector corresponding to \\lambda_i.\n" +
+   "The user may determine the number of points on the L-curve by\n" +
+   "adjusting the size of these input arrays. For the TSQR method,\n" +
+   "the regularization parameters \\lambda_i are estimated from the\n" +
+   "singular values of the triangular R factor. For the normal\n" +
+   "equations method, they are estimated from the eigenvalues of the\n" +
+   "X^T X matrix."},
+ {:func_name=>"gsl_multilarge_linear_name",
+  :func_type=>"const char *",
+  :args=>[["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "This function returns a string pointer to the name\n" +
+   "of the multilarge solver."},
+ {:func_name=>"gsl_multilarge_linear_rcond",
+  :func_type=>"int",
+  :args=>
+   [["double *", "rcond"], ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "This function computes the reciprocal condition number, stored in\n" +
+   "rcond, of the least squares matrix after it has been accumulated\n" +
+   "into the workspace work. For the TSQR algorithm, this is\n" +
+   "accomplished by calculating the SVD of the R factor, which\n" +
+   "has the same singular values as the matrix X. For the normal\n" +
+   "equations method, this is done by computing the eigenvalues of\n" +
+   "X^T X, which could be inaccurate for ill-conditioned matrices\n" +
+   "X."},
+ {:func_name=>"gsl_multilarge_linear_reset",
+  :func_type=>"int",
+  :args=>[["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "This function resets the workspace w so\n" +
+   "it can begin to accumulate a new least squares\n" +
+   "system."},
+ {:func_name=>"gsl_multilarge_linear_solve",
+  :func_type=>"int",
+  :args=>
+   [["const double", "lambda"],
+    ["gsl_vector *", "c"],
+    ["double *", "rnorm"],
+    ["double *", "snorm"],
+    ["gsl_multilarge_linear_workspace *", "w"]],
+  :desc=>
+   "After all blocks (X_i,y_i) have been accumulated into\n" +
+   "the large least squares system, this function will compute\n" +
+   "the solution vector which is stored in c on output.\n" +
+   "The regularization parameter \\lambda is provided in\n" +
+   "lambda. On output, rnorm contains the residual norm\n" +
+   "||y - X c||_W and snorm contains the solution\n" +
+   "norm ||L c||."},
+ {:func_name=>"gsl_multilarge_linear_stdform1",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_vector *", "L"],
+    ["const gsl_matrix *", "X"],
+    ["const gsl_vector *", "y"],
+    ["gsl_matrix *", "Xs"],
+    ["gsl_vector *", "ys"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "These functions define a regularization matrix\n" +
+   "L = diag(l_0,l_1,...,l_{p-1}).\n" +
+   "The diagonal matrix element l_i is provided by the\n" +
+   "ith element of the input vector L.\n" +
+   "The block (X,y) is converted to standard form and\n" +
+   "the parameters (\\tilde{X},\\tilde{y}) are stored in Xs\n" +
+   "and ys on output.  Xs and ys have the same dimensions as\n" +
+   "X and y. Optional data weights may be supplied in the\n" +
+   "vector w. In order to apply this transformation,\n" +
+   "L^{-1} must exist and so none of the l_i\n" +
+   "may be zero. After the standard form system has been solved,\n" +
+   "use gsl_multilarge_linear_genform1 to recover the original solution vector.\n" +
+   "It is allowed to have X = Xs and y = ys for an in-place transform."},
+ {:func_name=>"gsl_multilarge_linear_stdform2",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_matrix *", "LQR"],
+    ["const gsl_vector *", "Ltau"],
+    ["const gsl_matrix *", "X"],
+    ["const gsl_vector *", "y"],
+    ["gsl_matrix *", "Xs"],
+    ["gsl_vector *", "ys"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "These functions convert a block of rows (X,y,w) to standard\n" +
+   "form (\\tilde{X},\\tilde{y}) which are stored in Xs and ys\n" +
+   "respectively. X, y, and w must all have the same number of rows.\n" +
+   "The m-by-p regularization matrix L is specified by the inputs\n" +
+   "LQR and Ltau, which are outputs from gsl_multilarge_linear_L_decomp.\n" +
+   "Xs and ys have the same dimensions as X and y. After the\n" +
+   "standard form system has been solved, use gsl_multilarge_linear_genform2 to\n" +
+   "recover the original solution vector. Optional data weights may be supplied in the\n" +
+   "vector w, where W = diag(w)."},
+ {:func_name=>"gsl_multilarge_linear_wstdform1",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_vector *", "L"],
+    ["const gsl_matrix *", "X"],
+    ["const gsl_vector *", "w"],
+    ["const gsl_vector *", "y"],
+    ["gsl_matrix *", "Xs"],
+    ["gsl_vector *", "ys"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "These functions define a regularization matrix\n" +
+   "L = diag(l_0,l_1,...,l_{p-1}).\n" +
+   "The diagonal matrix element l_i is provided by the\n" +
+   "ith element of the input vector L.\n" +
+   "The block (X,y) is converted to standard form and\n" +
+   "the parameters (\\tilde{X},\\tilde{y}) are stored in Xs\n" +
+   "and ys on output.  Xs and ys have the same dimensions as\n" +
+   "X and y. Optional data weights may be supplied in the\n" +
+   "vector w. In order to apply this transformation,\n" +
+   "L^{-1} must exist and so none of the l_i\n" +
+   "may be zero. After the standard form system has been solved,\n" +
+   "use gsl_multilarge_linear_genform1 to recover the original solution vector.\n" +
+   "It is allowed to have X = Xs and y = ys for an in-place transform."},
+ {:func_name=>"gsl_multilarge_linear_wstdform2",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_matrix *", "LQR"],
+    ["const gsl_vector *", "Ltau"],
+    ["const gsl_matrix *", "X"],
+    ["const gsl_vector *", "w"],
+    ["const gsl_vector *", "y"],
+    ["gsl_matrix *", "Xs"],
+    ["gsl_vector *", "ys"],
+    ["gsl_multilarge_linear_workspace *", "work"]],
+  :desc=>
+   "These functions convert a block of rows (X,y,w) to standard\n" +
+   "form (\\tilde{X},\\tilde{y}) which are stored in Xs and ys\n" +
+   "respectively. X, y, and w must all have the same number of rows.\n" +
+   "The m-by-p regularization matrix L is specified by the inputs\n" +
+   "LQR and Ltau, which are outputs from gsl_multilarge_linear_L_decomp.\n" +
+   "Xs and ys have the same dimensions as X and y. After the\n" +
+   "standard form system has been solved, use gsl_multilarge_linear_genform2 to\n" +
+   "recover the original solution vector. Optional data weights may be supplied in the\n" +
+   "vector w, where W = diag(w)."}]

data/ext/numo/gsl/numo_gsl.h

@@ -0,0 +1,117 @@
+#ifndef NUMO_GSL_H
+#define NUMO_GSL_H
+
+#define GET_PTR(lp,i) NDL_PTR(lp,i)
+// (((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos)
+
+#if SIZEOF_INT == 4
+#define cI numo_cInt32
+#define cUI numo_cUInt32
+#elif SIZEOF_INT==8
+#define cI numo_cInt64
+#define cUI numo_cUInt64
+#endif
+
+#if SIZEOF_SIZE_T == 4
+#define cSZ numo_cUInt32
+#define cSSZ numo_cInt32
+#elif SIZEOF_SIZE_T == 8
+#define cSZ numo_cUInt64
+#define cSSZ numo_cInt64
+#endif
+
+#define cDF numo_cDFloat
+#define cDC numo_cDComplex
+#define cInt cI
+#define cUInt cUI
+
+#define ALLOCA_GSL_VECTOR_FROM_NARRAY(nary,gvec,mode)               \
+    {                                                               \
+        narray_t *na;                                               \
+        GetNArray(nary,na);                                         \
+        gvec = ALLOCA_N(gsl_vector,1);                              \
+        gvec->data   = (double*)na_get_pointer_for_##mode(nary);    \
+        gvec->size   = na->shape[0];                                \
+        gvec->stride = 1;                                           \
+        gvec->block  = 0;                                           \
+        gvec->owner  = 0;                                           \
+    }
+
+#define ALLOCA_GSL_MATRIX_FROM_NARRAY(nary,gmat,mode)           \
+    {                                                           \
+        narray_t *na;                                           \
+        GetNArray(nary,na);                                     \
+        gmat = ALLOCA_N(gsl_matrix,1);                          \
+        gmat->data  = (double*)na_get_pointer_for_##mode(nary); \
+        gmat->size1 = na->shape[0];                             \
+        gmat->size2 = na->shape[1];                             \
+        gmat->tda   = na->shape[1];                             \
+        gmat->block = 0;                                        \
+        gmat->owner = 0;                                        \
+    }
+
+#define ALLOCA_GSL_VECTOR_FROM_NARRAY_R(nary,gvec)      \
+    ALLOCA_GSL_VECTOR_FROM_NARRAY(nary,gvec,read)
+#define ALLOCA_GSL_MATRIX_FROM_NARRAY_R(nary,gmat)      \
+    ALLOCA_GSL_MATRIX_FROM_NARRAY(nary,gmat,read)
+#define ALLOCA_GSL_VECTOR_FROM_NARRAY_W(nary,gvec)      \
+    ALLOCA_GSL_VECTOR_FROM_NARRAY(nary,gvec,write)
+#define ALLOCA_GSL_MATRIX_FROM_NARRAY_W(nary,gmat)      \
+    ALLOCA_GSL_MATRIX_FROM_NARRAY(nary,gmat,write)
+#define ALLOCA_GSL_VECTOR_FROM_NARRAY_RW(nary,gvec)     \
+    ALLOCA_GSL_VECTOR_FROM_NARRAY(nary,gvec,read_write)
+#define ALLOCA_GSL_MATRIX_FROM_NARRAY_RW(nary,gmat)     \
+    ALLOCA_GSL_MATRIX_FROM_NARRAY(nary,gmat,read_write)
+
+#define ALLOCA_GSL_MATRIX_FROM_LOOPT(lp,i,gmat) \
+    {                                           \
+        assert((lp)->args[i].ndim == 2);        \
+        gmat = ALLOCA_N(gsl_matrix,1);          \
+        gmat->data  = (double*)NDL_PTR(lp,i);   \
+        gmat->size1 = (lp)->args[i].shape[0];   \
+        gmat->size2 = (lp)->args[i].shape[1];   \
+        gmat->tda   = gmat->size2;              \
+        gmat->block = 0;                        \
+        gmat->owner = 0;                        \
+    }
+
+#define ALLOCA_GSL_VECTOR_FROM_LOOPT(lp,i,gvec)         \
+    {                                                   \
+        assert((lp)->args[i].ndim == 1);                \
+        gvec = ALLOCA_N(gsl_vector,1);                  \
+        gvec->data   = (double*)NDL_PTR(lp,i);          \
+        gvec->size   = (lp)->args[i].shape[0];          \
+        gvec->stride = NDL_SETP(lp,i)/sizeof(double);   \
+        gvec->block  = 0;                               \
+        gvec->owner  = 0;                               \
+    }
+
+#define SET_GSL_MATRIX_FROM_LOOPT(lp,i,gmat)    \
+    {                                           \
+        assert((lp)->args[i].ndim == 2);        \
+        gmat.data  = (double*)NDL_PTR(lp,i);    \
+        gmat.size1 = (lp)->args[i].shape[0];    \
+        gmat.size2 = (lp)->args[i].shape[1];    \
+        gmat.tda   = gmat.size2;                \
+        gmat.block = 0;                         \
+        gmat.owner = 0;                         \
+    }
+
+#define SET_GSL_VECTOR_FROM_LOOPT(lp,i,gvec)            \
+    {                                                   \
+        assert((lp)->args[i].ndim == 1);                \
+        gvec.data   = (double*)NDL_PTR(lp,i);           \
+        gvec.size   = (lp)->args[i].shape[0];           \
+        gvec.stride = NDL_STEP(lp,i)/sizeof(double);    \
+        gvec.block  = 0;                                \
+        gvec.owner  = 0;                                \
+    }
+
+#define MAT_SIZE1(x) ((x)->shape[(x)->ndim-2])
+#define MAT_SIZE2(x) ((x)->shape[(x)->ndim-1])
+#define VEC_SIZE(x)  ((x)->shape[(x)->ndim-1])
+#define CHECK_GE_1D(x) {if ((x)->ndim < 1) {rb_raise(nary_eDimensionError,#x" dimension must be >= 1");}}
+#define CHECK_GE_2D(x) {if ((x)->ndim < 2) {rb_raise(nary_eDimensionError,#x" dimension must be >= 2");}}
+#define CHECK_SIZE_EQ(x,y,msg) {if ((x)!=(y)) {rb_raise(nary_eShapeError,msg);}}
+
+#endif /* ifndef NUMO_GSL_H */

data/ext/numo/gsl/pdf/depend

@@ -0,0 +1,17 @@
+COGEN=ruby erbpp_pdf.rb
+GENSRC=gsl_pdf.c
+GENDEPS=erbpp_pdf.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/pdf/erbpp_pdf.rb

@@ -0,0 +1,27 @@
+require_relative "../gen/erbpp_gsl"
+require_relative "parse_pdf"
+
+DefLib.new do
+  set line_number: true
+  set erb_dir: %w[tmpl ../gen/tmpl]
+  set erb_suffix: ".c"
+  set ns_var: "mG"
+
+  name = "Pdf"
+  base = name.downcase
+  set file_name: "gsl_#{name}.c"
+  set include_files: ["gsl/gsl_randist.h"]
+  set lib_name: base
+
+  DefPdf.new(self) do
+    set name: base
+    set module_name: name
+    set module_var: "m"+name
+    set full_module_name: "Numo::GSL::"+name
+
+    ErbppGsl.read_func.each do |h|
+      check_func(h)
+    end
+  end
+
+end.run

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

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