numo-gsl 0.1.0

data/ext/numo/gsl/multifit/tmpl/multifit_linear.c

@@ -0,0 +1,66 @@
+static VALUE cLinearResult;
+
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    gsl_matrix X;
+    gsl_vector y;
+    gsl_vector c;
+    gsl_matrix cov;
+    double *chisq;
+    <%=struct%> *ws = (<%=struct%>*)(lp->opt_ptr);
+
+    SET_GSL_MATRIX_FROM_LOOPT(lp,0,X);
+    SET_GSL_VECTOR_FROM_LOOPT(lp,1,y);
+    SET_GSL_VECTOR_FROM_LOOPT(lp,2,c);
+    SET_GSL_MATRIX_FROM_LOOPT(lp,3,cov);
+    chisq = (double*)NDL_PTR(lp,4);
+
+    <%=func_name%>(&X,&y,&c,&cov,chisq,ws);
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>)
+  @param  [DFloat]    <%=args[0][1]%> (input matrix) predictor variables
+  @param  [DFloat]    <%=args[1][1]%> (input vector) observation
+  @return [GSL::Multifit::LinearResult] result Struct with members: <%=args[2][1]%>, <%=args[3][1]%>, <%=args[4][1]%>.
+
+  <%=desc%>
+
+*/
+static VALUE
+<%=c_func(2)%>(VALUE mod, VALUE v1, VALUE v2)
+{
+    size_t c_shape[1], cov_shape[2];
+    ndfunc_arg_in_t ain[2] = {{cDF,2},{cDF,1}};
+    ndfunc_arg_out_t aout[3] = {{cDF,1,c_shape},{cDF,2,cov_shape},{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, NO_LOOP|NDF_EXTRACT,
+                     2, 3, ain, aout };
+    VALUE vws, r, result;
+    narray_t *X, *y;
+    size_t n, p;
+    <%=struct%> *ws;
+
+    GetNArray(v1,X);
+    GetNArray(v2,y);
+    CHECK_GE_2D(X);
+    CHECK_GE_1D(y);
+    n = MAT_SIZE1(X);
+    p = MAT_SIZE2(X);
+    CHECK_SIZE_EQ(n,VEC_SIZE(y),"y size does not match X column size");
+
+    c_shape[0] = cov_shape[0] = cov_shape[1] = p;
+
+    ws = gsl_multifit_linear_alloc(n,p);
+    if (!ws)
+        rb_raise(rb_eNoMemError,"fail to allocate struct");
+    vws = TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, (void*)ws);
+
+    r = na_ndloop3(&ndf, ws, 2, v1, v2);
+
+    result = rb_class_new_instance(3, RARRAY_PTR(r), cLinearResult);
+
+    RB_GC_GUARD(vws);
+    RB_GC_GUARD(r);
+    return result;
+}

data/ext/numo/gsl/multifit/tmpl/multifit_linear_est.c

@@ -0,0 +1,48 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    gsl_vector x;
+    gsl_vector c;
+    gsl_matrix cov;
+    double   y, yerr;
+
+    SET_GSL_VECTOR_FROM_LOOPT(lp,0,x);
+    SET_GSL_VECTOR_FROM_LOOPT(lp,1,c);
+    SET_GSL_MATRIX_FROM_LOOPT(lp,2,cov);
+
+    <%=func_name%>(&x, &c, &cov, &y, &yerr);
+
+    *(double*)NDL_PTR(lp,3) = y;
+    *(double*)NDL_PTR(lp,4) = yerr;
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,<%=args[2][1]%>)
+  @param  [DFloat]    <%=args[0][1]%> (input vector) observations
+  @param  [DFloat]    <%=args[1][1]%> (input vector) solusions
+  @param  [DFloat]    <%=args[2][1]%> (input matrix) covariance
+  @return [[DFloat,DFloat]] array of (<%=args[3][1]%>, <%=args[4][1]%>).
+
+  <%=desc%>
+
+*/
+static VALUE
+<%=c_func(3)%>(VALUE mod, VALUE v1, VALUE v2, VALUE v3)
+{
+    ndfunc_arg_in_t ain[3] = {{cDF,1},{cDF,1},{cDF,2}};
+    ndfunc_arg_out_t aout[2] = {{cDF,0},{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, NO_LOOP|NDF_EXTRACT,
+                     3, 2, ain, aout };
+    narray_t *x, *c, *cov;
+
+    GetNArray(v1,x);
+    GetNArray(v2,c);
+    GetNArray(v3,cov);
+    CHECK_GE_1D(x);
+    CHECK_GE_1D(c);
+    CHECK_GE_2D(cov);
+    CHECK_SIZE_EQ(VEC_SIZE(x),VEC_SIZE(c),"x size does not match c size");
+    CHECK_SIZE_EQ(MAT_SIZE1(cov),MAT_SIZE2(cov),"cov is not square matrix");
+    CHECK_SIZE_EQ(VEC_SIZE(c),MAT_SIZE1(cov),"c size does not match cov row size");
+    return na_ndloop(&ndf, 3, v1, v2, v3);
+}

data/ext/numo/gsl/multifit/tmpl/multifit_linear_residuals.c

@@ -0,0 +1,47 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    gsl_matrix x;
+    gsl_vector y;
+    gsl_vector c;
+    gsl_vector r;
+
+    SET_GSL_MATRIX_FROM_LOOPT(lp,0,x);
+    SET_GSL_VECTOR_FROM_LOOPT(lp,1,y);
+    SET_GSL_VECTOR_FROM_LOOPT(lp,2,c);
+    SET_GSL_VECTOR_FROM_LOOPT(lp,3,r);
+
+    <%=func_name%>(&x, &y, &c, &r);
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,<%=args[2][1]%>)
+  @param  [DFloat]    <%=args[0][1]%> (input matrix) design matrix
+  @param  [DFloat]    <%=args[1][1]%> (input vector) rhs vector
+  @param  [DFloat]    <%=args[2][1]%> (input vector) fit coefficients
+  @return [DFloat]    returns <%=args[3][1]%>
+
+  <%=desc%>
+
+*/
+static VALUE
+<%=c_func(3)%>(VALUE mod, VALUE v1, VALUE v2, VALUE v3)
+{
+    size_t shape[1];
+    ndfunc_arg_in_t ain[3] = {{cDF,2},{cDF,1},{cDF,1}};
+    ndfunc_arg_out_t aout[1] = {{cDF,1,shape}};
+    ndfunc_t ndf = { iter_<%=c_func%>, NO_LOOP|NDF_EXTRACT,
+                     3, 1, ain, aout };
+    narray_t *x, *y, *c;
+
+    GetNArray(v1,x);
+    GetNArray(v2,y);
+    GetNArray(v3,c);
+    CHECK_GE_2D(x);
+    CHECK_GE_1D(y);
+    CHECK_GE_1D(c);
+    CHECK_SIZE_EQ(MAT_SIZE1(x),VEC_SIZE(y),"y size does not match x row size");
+    CHECK_SIZE_EQ(MAT_SIZE2(x),VEC_SIZE(c),"c size does not match x column size");
+    shape[0] = VEC_SIZE(y);
+    return na_ndloop(&ndf, 3, v1, v2, v3);
+}

data/ext/numo/gsl/multifit/tmpl/multifit_wlinear.c

@@ -0,0 +1,70 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    gsl_matrix X;
+    gsl_vector y;
+    gsl_vector w;
+    gsl_vector c;
+    gsl_matrix cov;
+    double *chisq;
+    <%=struct%> *ws = (<%=struct%>*)(lp->opt_ptr);
+
+    SET_GSL_MATRIX_FROM_LOOPT(lp,0,X);
+    SET_GSL_VECTOR_FROM_LOOPT(lp,1,y);
+    SET_GSL_VECTOR_FROM_LOOPT(lp,2,w);
+    SET_GSL_VECTOR_FROM_LOOPT(lp,3,c);
+    SET_GSL_MATRIX_FROM_LOOPT(lp,4,cov);
+    chisq = (double*)NDL_PTR(lp,5);
+
+    <%=func_name%>(&X,&y,&w,&c,&cov,chisq,ws);
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,<%=args[2][1]%>)
+  @param  [DFloat]    <%=args[0][1]%> (input matrix) predictor variables
+  @param  [DFloat]    <%=args[1][1]%> (input vector) observations
+  @param  [DFloat]    <%=args[2][1]%> (input vector) weights
+  @return [GSL::Multifit::LinearResult] result Struct with members: <%=args[3][1]%>, <%=args[4][1]%>, <%=args[5][1]%>.
+
+  <%=desc%>
+
+*/
+static VALUE
+<%=c_func(3)%>(VALUE mod, VALUE v1, VALUE v2, VALUE v3)
+{
+    size_t c_shape[1], cov_shape[2];
+    ndfunc_arg_in_t ain[3] = {{cDF,2},{cDF,1},{cDF,1}};
+    ndfunc_arg_out_t aout[3] = {{cDF,1,c_shape},{cDF,2,cov_shape},{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, NO_LOOP|NDF_EXTRACT,
+                     3, 3, ain, aout };
+    VALUE vws, r, result;
+    narray_t *X, *y, *w;
+    size_t n, p;
+    <%=struct%> *ws;
+
+    GetNArray(v1,X);
+    GetNArray(v2,y);
+    GetNArray(v3,w);
+    CHECK_GE_2D(X);
+    CHECK_GE_1D(y);
+    CHECK_GE_1D(w);
+    n = MAT_SIZE1(X);
+    p = MAT_SIZE2(X);
+    CHECK_SIZE_EQ(n,VEC_SIZE(y),"y size does not match X column size");
+    CHECK_SIZE_EQ(n,VEC_SIZE(w),"w size does not match X column size");
+
+    c_shape[0] = cov_shape[0] = cov_shape[1] = p;
+
+    ws = gsl_multifit_linear_alloc(n,p);
+    if (!ws)
+        rb_raise(rb_eNoMemError,"fail to allocate struct");
+    vws = TypedData_Wrap_Struct(<%=class_var%>, &<%=data_type_var%>, (void*)ws);
+
+    r = na_ndloop3(&ndf, ws, 3, v1, v2, v3);
+
+    result = rb_class_new_instance(3, RARRAY_PTR(r), cLinearResult);
+
+    RB_GC_GUARD(vws);
+    RB_GC_GUARD(r);
+    return result;
+}

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

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

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_STP(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_STP(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,26 @@
+require_relative "parse_pdf"
+require "erbpp/line_number"
+
+DefLib.new do
+  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')

data/ext/numo/gsl/pdf/func_2.2.1.rb

@@ -0,0 +1,306 @@
+[{:func_name=>"gsl_ran_gaussian_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "sigma"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Gaussian distribution with standard deviation sigma, using\n" +
+   "the formula given above."},
+ {:func_name=>"gsl_ran_ugaussian_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"]],
+  :desc=>
+   "These functions compute results for the unit Gaussian distribution.  They\n" +
+   "are equivalent to the functions above with a standard deviation of one,\n" +
+   "sigma = 1."},
+ {:func_name=>"gsl_ran_gaussian_tail_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "sigma"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Gaussian tail distribution with standard deviation sigma and\n" +
+   "lower limit a, using the formula given above."},
+ {:func_name=>"gsl_ran_ugaussian_tail_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"]],
+  :desc=>
+   "These functions compute results for the tail of a unit Gaussian\n" +
+   "distribution.  They are equivalent to the functions above with a standard\n" +
+   "deviation of one, sigma = 1."},
+ {:func_name=>"gsl_ran_bivariate_gaussian_pdf",
+  :func_type=>"double",
+  :args=>
+   [["double", "x"],
+    ["double", "y"],
+    ["double", "sigma_x"],
+    ["double", "sigma_y"],
+    ["double", "rho"]],
+  :desc=>
+   "This function computes the probability density p(x,y) at\n" +
+   "(x,y) for a bivariate Gaussian distribution with standard\n" +
+   "deviations sigma_x, sigma_y and correlation coefficient\n" +
+   "rho, using the formula given above."},
+ {:func_name=>"gsl_ran_multivariate_gaussian_pdf",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_vector *", "x"],
+    ["const gsl_vector *", "mu"],
+    ["const gsl_matrix *", "L"],
+    ["double *", "result"],
+    ["gsl_vector *", "work"]],
+  :desc=>
+   "These functions compute p(x) or \\log{p(x)} at the point x, using mean vector\n" +
+   "mu and variance-covariance matrix specified by its Cholesky factor L using the formula\n" +
+   "above. Additional workspace of length k is required in work."},
+ {:func_name=>"gsl_ran_multivariate_gaussian_log_pdf",
+  :func_type=>"int",
+  :args=>
+   [["const gsl_vector *", "x"],
+    ["const gsl_vector *", "mu"],
+    ["const gsl_matrix *", "L"],
+    ["double *", "result"],
+    ["gsl_vector *", "work"]],
+  :desc=>
+   "These functions compute p(x) or \\log{p(x)} at the point x, using mean vector\n" +
+   "mu and variance-covariance matrix specified by its Cholesky factor L using the formula\n" +
+   "above. Additional workspace of length k is required in work."},
+ {:func_name=>"gsl_ran_exponential_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "mu"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for an exponential distribution with mean mu, using the formula\n" +
+   "given above."},
+ {:func_name=>"gsl_ran_laplace_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Laplace distribution with width a, using the formula\n" +
+   "given above."},
+ {:func_name=>"gsl_ran_exppow_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for an exponential power distribution with scale parameter a\n" +
+   "and exponent b, using the formula given above."},
+ {:func_name=>"gsl_ran_cauchy_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Cauchy distribution with scale parameter a, using the formula\n" +
+   "given above."},
+ {:func_name=>"gsl_ran_rayleigh_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "sigma"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Rayleigh distribution with scale parameter sigma, using the\n" +
+   "formula given above."},
+ {:func_name=>"gsl_ran_rayleigh_tail_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "sigma"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Rayleigh tail distribution with scale parameter sigma and\n" +
+   "lower limit a, using the formula given above."},
+ {:func_name=>"gsl_ran_landau_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for the Landau distribution using an approximation to the formula given\n" +
+   "above."},
+ {:func_name=>"gsl_ran_gamma_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a gamma distribution with parameters a and b, using the\n" +
+   "formula given above."},
+ {:func_name=>"gsl_ran_flat_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a uniform distribution from a to b, using the formula\n" +
+   "given above."},
+ {:func_name=>"gsl_ran_lognormal_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "zeta"], ["double", "sigma"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a lognormal distribution with parameters zeta and sigma,\n" +
+   "using the formula given above."},
+ {:func_name=>"gsl_ran_chisq_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "nu"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a chi-squared distribution with nu degrees of freedom, using\n" +
+   "the formula given above."},
+ {:func_name=>"gsl_ran_fdist_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "nu1"], ["double", "nu2"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for an F-distribution with nu1 and nu2 degrees of freedom,\n" +
+   "using the formula given above."},
+ {:func_name=>"gsl_ran_tdist_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "nu"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a t-distribution with nu degrees of freedom, using the formula\n" +
+   "given above."},
+ {:func_name=>"gsl_ran_beta_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a beta distribution with parameters a and b, using the\n" +
+   "formula given above."},
+ {:func_name=>"gsl_ran_logistic_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a logistic distribution with scale parameter a, using the\n" +
+   "formula given above."},
+ {:func_name=>"gsl_ran_pareto_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Pareto distribution with exponent a and scale b, using\n" +
+   "the formula given above."},
+ {:func_name=>"gsl_ran_weibull_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Weibull distribution with scale a and exponent b,\n" +
+   "using the formula given above."},
+ {:func_name=>"gsl_ran_gumbel1_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Type-1 Gumbel distribution with parameters a and b,\n" +
+   "using the formula given above."},
+ {:func_name=>"gsl_ran_gumbel2_pdf",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function computes the probability density p(x) at x\n" +
+   "for a Type-2 Gumbel distribution with parameters a and b,\n" +
+   "using the formula given above."},
+ {:func_name=>"gsl_ran_dirichlet_pdf",
+  :func_type=>"double",
+  :args=>
+   [["size_t", "K"], ["const double", "alpha[]"], ["const double", "theta[]"]],
+  :desc=>
+   "This function computes the probability density \n" +
+   "$p(\\theta_1, \\ldots , \\theta_K)$\n" +
+   "p(\\theta_1, ... , \\theta_K)\n" +
+   "at theta[K] for a Dirichlet distribution with parameters \n" +
+   "alpha[K], using the formula given above."},
+ {:func_name=>"gsl_ran_dirichlet_lnpdf",
+  :func_type=>"double",
+  :args=>
+   [["size_t", "K"], ["const double", "alpha[]"], ["const double", "theta[]"]],
+  :desc=>
+   "This function computes the logarithm of the probability density \n" +
+   "$p(\\theta_1, \\ldots , \\theta_K)$\n" +
+   "p(\\theta_1, ... , \\theta_K)\n" +
+   "for a Dirichlet distribution with parameters \n" +
+   "alpha[K]."},
+ {:func_name=>"gsl_ran_discrete_pdf",
+  :func_type=>"double",
+  :args=>[["size_t", "k"], ["const gsl_ran_discrete_t *", "g"]],
+  :desc=>
+   "Returns the probability P[k] of observing the variable k.\n" +
+   "Since P[k] is not stored as part of the lookup table, it must be\n" +
+   "recomputed; this computation takes O(K), so if K is large\n" +
+   "and you care about the original array P[k] used to create the\n" +
+   "lookup table, then you should just keep this original array P[k]\n" +
+   "around."},
+ {:func_name=>"gsl_ran_poisson_pdf",
+  :func_type=>"double",
+  :args=>[["unsigned int", "k"], ["double", "mu"]],
+  :desc=>
+   "This function computes the probability p(k) of obtaining  k\n" +
+   "from a Poisson distribution with mean mu, using the formula\n" +
+   "given above."},
+ {:func_name=>"gsl_ran_bernoulli_pdf",
+  :func_type=>"double",
+  :args=>[["unsigned int", "k"], ["double", "p"]],
+  :desc=>
+   "This function computes the probability p(k) of obtaining\n" +
+   "k from a Bernoulli distribution with probability parameter\n" +
+   "p, using the formula given above."},
+ {:func_name=>"gsl_ran_binomial_pdf",
+  :func_type=>"double",
+  :args=>[["unsigned int", "k"], ["double", "p"], ["unsigned int", "n"]],
+  :desc=>
+   "This function computes the probability p(k) of obtaining k\n" +
+   "from a binomial distribution with parameters p and n, using\n" +
+   "the formula given above."},
+ {:func_name=>"gsl_ran_multinomial_pdf",
+  :func_type=>"double",
+  :args=>
+   [["size_t", "K"], ["const double", "p[]"], ["const unsigned int", "n[]"]],
+  :desc=>
+   "This function computes the probability \n" +
+   "$P(n_1, n_2, \\ldots, n_K)$\n" +
+   "P(n_1, n_2, ..., n_K)\n" +
+   "of sampling n[K] from a multinomial distribution \n" +
+   "with parameters p[K], using the formula given above."},
+ {:func_name=>"gsl_ran_multinomial_lnpdf",
+  :func_type=>"double",
+  :args=>
+   [["size_t", "K"], ["const double", "p[]"], ["const unsigned int", "n[]"]],
+  :desc=>
+   "This function returns the logarithm of the probability for the\n" +
+   "multinomial distribution $P(n_1, n_2, \\ldots, n_K)$\n" +
+   "P(n_1, n_2, ..., n_K) with parameters p[K]."},
+ {:func_name=>"gsl_ran_negative_binomial_pdf",
+  :func_type=>"double",
+  :args=>[["unsigned int", "k"], ["double", "p"], ["double", "n"]],
+  :desc=>
+   "This function computes the probability p(k) of obtaining k\n" +
+   "from a negative binomial distribution with parameters p and\n" +
+   "n, using the formula given above."},
+ {:func_name=>"gsl_ran_pascal_pdf",
+  :func_type=>"double",
+  :args=>[["unsigned int", "k"], ["double", "p"], ["unsigned int", "n"]],
+  :desc=>
+   "This function computes the probability p(k) of obtaining k\n" +
+   "from a Pascal distribution with parameters p and\n" +
+   "n, using the formula given above."},
+ {:func_name=>"gsl_ran_geometric_pdf",
+  :func_type=>"double",
+  :args=>[["unsigned int", "k"], ["double", "p"]],
+  :desc=>
+   "This function computes the probability p(k) of obtaining k\n" +
+   "from a geometric distribution with probability parameter p, using\n" +
+   "the formula given above."},
+ {:func_name=>"gsl_ran_hypergeometric_pdf",
+  :func_type=>"double",
+  :args=>
+   [["unsigned int", "k"],
+    ["unsigned int", "n1"],
+    ["unsigned int", "n2"],
+    ["unsigned int", "t"]],
+  :desc=>
+   "This function computes the probability p(k) of obtaining k\n" +
+   "from a hypergeometric distribution with parameters n1, n2,\n" +
+   "t, using the formula given above."},
+ {:func_name=>"gsl_ran_logarithmic_pdf",
+  :func_type=>"double",
+  :args=>[["unsigned int", "k"], ["double", "p"]],
+  :desc=>
+   "This function computes the probability p(k) of obtaining k\n" +
+   "from a logarithmic distribution with probability parameter p,\n" +
+   "using the formula given above."}]