Also expose uniform generator

Author: eddelbuettel

ChangeLog

@@ -1,3 +1,11 @@
+2025-01-03  Dirk Eddelbuettel  <[email protected]>
+
+	* inst/include/Ziggurat.h (runi): Expose interally used uniform RNG
+	* src/ziggurat.cpp (zruni): Provide R-accessible wrapper for runi()
+	* man/ziggurat.Rd: Document zrexp() and zruni()
+	* src/RcppExports.cpp: Regenerated
+	* R/RcppExports.R: Idem
+
 2025-01-02  Dirk Eddelbuettel  <[email protected]>
 
 	* inst/include/Ziggurat.h (kiss): Use an inline function avoiding a

DESCRIPTION

@@ -10,7 +10,7 @@ Description: The Ziggurat generator for normally distributed random
  <doi:10.18637/jss.v005.i08>) has been improved upon a few times
  starting with Leong et al (2005, <doi:10.18637/jss.v012.i07>).
  This package provides an aggregation in order to compare different
- implementations in order to provide an 'faster but good enough'
+ implementations in order to provide a 'faster but good enough'
  alternative for use with R and C++ code.
 License: GPL (>= 2)
 Depends: R (>= 3.0.0)

R/RcppExports.R

@@ -45,6 +45,10 @@ zrexp <- function(n) {
     .Call(`_RcppZiggurat_zrexp`, n)
 }
 
+zruni <- function(n) {
+    .Call(`_RcppZiggurat_zruni`, n)
+}
+
 zrnormVec <- function(x) {
     .Call(`_RcppZiggurat_zrnormVec`, x)
 }

inst/include/Ziggurat.h

@@ -96,6 +96,9 @@ namespace Ziggurat {
         inline double rexp() {
             return (jz = kiss(), iz = jz & 255, (       jz   < ke[iz] ) ? jz * we[iz] : efix());
         }
+        inline double runi() {
+            return ( 0.5 + ( signed ) KISS * 0.2328306e-09 );
+        }
         std::vector<uint32_t> getPars() {
             //C++11: std::vector<uint32_t> pars{ jsr, z, w, jcong };
             std::vector<uint32_t> pars;

man/ziggurat.Rd

@@ -1,6 +1,7 @@
 \name{zrnorm}
 \alias{zrnorm}
 \alias{zrexp}
+\alias{zruni}
 \alias{zrnormLZLLV}
 \alias{zrnormMT}
 \alias{zrnormV1}
@@ -38,6 +39,7 @@
 \usage{
   zrnorm(n)
   zrexp(n)
+  zruni(n)
   zrnormLZLLV(n)
   zrnormMT(n)
   zrnormV1(n)
@@ -76,6 +78,10 @@
   actually not sufficient to capture the state, so \code{zgetpars}
   \code{zsetpars} provide this functionality with a vector of size four.
   Use these functions with caution.
+
+  Following the original paper, \code{rexp} also provides a vector of random
+  draws from the exponential distribution. In addition, \code{runi} offers random
+  draws from the uniform distribution (which is used internally).
 
 }
 \details{

src/RcppExports.cpp

@@ -128,6 +128,17 @@ BEGIN_RCPP
     return rcpp_result_gen;
 END_RCPP
 }
+// zruni
+Rcpp::NumericVector zruni(int n);
+RcppExport SEXP _RcppZiggurat_zruni(SEXP nSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::RNGScope rcpp_rngScope_gen;
+    Rcpp::traits::input_parameter< int >::type n(nSEXP);
+    rcpp_result_gen = Rcpp::wrap(zruni(n));
+    return rcpp_result_gen;
+END_RCPP
+}
 // zrnormVec
 Rcpp::NumericVector zrnormVec(Rcpp::NumericVector x);
 RcppExport SEXP _RcppZiggurat_zrnormVec(SEXP xSEXP) {
@@ -332,6 +343,7 @@ static const R_CallMethodDef CallEntries[] = {
     {"_RcppZiggurat_zgetseedV1", (DL_FUNC) &_RcppZiggurat_zgetseedV1, 0},
     {"_RcppZiggurat_zrnorm", (DL_FUNC) &_RcppZiggurat_zrnorm, 1},
     {"_RcppZiggurat_zrexp", (DL_FUNC) &_RcppZiggurat_zrexp, 1},
+    {"_RcppZiggurat_zruni", (DL_FUNC) &_RcppZiggurat_zruni, 1},
     {"_RcppZiggurat_zrnormVec", (DL_FUNC) &_RcppZiggurat_zrnormVec, 1},
     {"_RcppZiggurat_zrnormStl", (DL_FUNC) &_RcppZiggurat_zrnormStl, 1},
     {"_RcppZiggurat_zsetseed", (DL_FUNC) &_RcppZiggurat_zsetseed, 1},

src/ziggurat.cpp

@@ -139,6 +139,15 @@ Rcpp::NumericVector zrexp(int n) {
     return x;
 }
 
+// [[Rcpp::export]]
+Rcpp::NumericVector zruni(int n) {
+    Rcpp::NumericVector x(n);
+    for (int i=0; i<n; i++) {
+        x[i] = zigg.runi();
+    }
+    return x;
+}
+
 // [[Rcpp::export]]
 Rcpp::NumericVector zrnormVec(Rcpp::NumericVector x) {
     int n = x.size();