Merge branch 'main' into list_return_1

Author: mns-nordicals

NEWS.md

@@ -1,10 +1,12 @@
 # quickr (development version)
 
-- Internal utility `r2f()` print method now shows the generated `c_bridge` 
+- Internal utility `r2f()` print method now shows the generated `c_bridge`
   for translated subroutines.
-  
+
 - Added support for `nrow()`, `ncol()` and `dim()` (#21, @mikmart).
 
+- Added support for `runif()` with integration to R's RNG (#22, #45).
+
 - Added support for `while`, `repeat`, `break`, `next`.
 
 - Added support for `%%` and `%/%`.
@@ -22,6 +24,14 @@
 
 - Fixed segfault encountered on Windows with variable sized arrays.
 
+- Added workaround for cases where the compiler error message might not
+  display correctly in RStudio.
+  
+- Improved error message when using case-sensitive variable names (#18, #36, #39)
+
+- Added `AGENTS.md` and `scripts/setup_codex.sh` to enable the ChatGPT/Codex agent 
+  to run tests in a docker container configured without internet access.
+  
 
 # quickr 0.1.0
 

R/c-wrapper.R

@@ -3,6 +3,7 @@ make_c_bridge <- function(fsub, strict = TRUE, headers = TRUE) {
 
   closure <- fsub@closure
   scope <- fsub@scope
+  uses_rng <- isTRUE(attr(scope, "uses_rng", TRUE))
 
   fsub_arg_names <- fsub@signature # arg names
   closure_arg_names <- names(formals(closure))
@@ -61,7 +62,9 @@ make_c_bridge <- function(fsub, strict = TRUE, headers = TRUE) {
 
   append(c_body) <- c(
     "",
+    if (uses_rng) "GetRNGstate();",
     glue("{fsub@name}({str_flatten_commas(fsub_call_args)});"),
+    if (uses_rng) "PutRNGstate();",
     ""
   )
   if (length(return_var_names) == 1L) {
@@ -93,14 +96,13 @@ make_c_bridge <- function(fsub, strict = TRUE, headers = TRUE) {
 
   fsub_extern_decl <- fsub_extern_decl(fsub)
 
-  c_headers <- glue::trim(
-    r"--(
-     #define R_NO_REMAP
-     #include <R.h>
-     #include <Rinternals.h>
-
-
-     )--"
+  c_headers <- str_flatten_lines(
+    "#define R_NO_REMAP",
+    "#include <R.h>",
+    "#include <Rinternals.h>",
+    if (uses_rng) "#include <R_ext/Random.h>",
+    "",
+    ""
   )
 
   as_glue(str_flatten_lines(c(

R/quick.R

@@ -3,7 +3,10 @@
 #' Compile an R function.
 #'
 #' @param fun An R function
-#' @param name Optional string, name to use for the function.
+#' @param name String, name to use for the function. This is optional in
+#'   regular usage but required in an R package. As a convenience, arguments
+#'   `fun` and `name` can also be supplied as positional arguments to `quick` with
+#'   `name` in the first position.
 #'
 #' @details
 #'
@@ -12,8 +15,9 @@
 #' The shape and mode of all function arguments must be declared. Local and
 #' return variables may optionally also be declared.
 #'
-#' `declare(type())` also has support for declaring size constraints, or size
-#' relationships between variables. Here are some examples of declare calls:
+#' `declare(type())` also has support for declaring size constraints, or
+#' size relationships between variables. Here are some examples of declare
+#' calls:
 #'
 #' ```r
 #' declare(type(x = double(NA))) # x is a 1-d double vector of any length
@@ -64,11 +68,11 @@
 #'
 #' ## Return values
 #'
-#' The shape and type of a function return value must be known at compile time.
-#' In most situations, this will be automatically inferred by `quick()`. However,
-#' if the output is dynamic, then you may need to provide a hint.
-#' For example, returning the result of `seq()` will fail because the output shape
-#' cannot be inferred.
+#' The shape and type of a function return value must be known at compile
+#' time. In most situations, this will be automatically inferred by
+#' `quick()`. However, if the output is dynamic, then you may need to
+#' provide a hint. For example, returning the result of `seq()` will fail
+#' because the output shape cannot be inferred.
 #'
 #' ```r
 #' # Will fail to compile:
@@ -82,8 +86,8 @@
 #' })
 #' ```
 #'
-#' However, if the output size can be declared as a dynamic expression using other
-#' values known at runtime, compilation will succeed:
+#' However, if the output size can be declared as a dynamic expression using
+#' other values known at runtime, compilation will succeed:
 #'
 #' ```r
 #' # Succeeds:
@@ -116,6 +120,8 @@ quick <- function(fun, name = NULL) {
     } else {
       make_unique_name(prefix = "anonymous_quick_function_")
     }
+  } else if (is.function(name) && is_string(fun)) {
+    .[name, fun] <- list(fun, name)
   }
 
   if (nzchar(pkgname <- Sys.getenv("DEVTOOLS_LOAD"))) {
@@ -143,6 +149,12 @@ quick <- function(fun, name = NULL) {
 
   pkgname <- parent.pkg()
   if (!is.null(pkgname) && pkgname != "quickr") {
+    if (startsWith(name, 'anonymous_quick_function_')) {
+      stop(
+        'When used in an R package, you must provide a unique `name` to every `quick()` call.\n',
+        'For example: `my_fun <- quick("my_fun", function(x) ....)'
+      )
+    }
     # we are in a package - but outside a quickr::compile_package() call.
     return(create_quick_closure(name, fun))
   }
@@ -184,10 +196,13 @@ compile <- function(fsub, build_dir = tempfile(paste0(fsub@name, "-build-"))) {
       stderr = TRUE
     )
   })
-  if (!is.null(attr(result, "status"))) {
+  if (!is.null(status <- attr(result, "status"))) {
+    # Adjust the compiler error so RStudio console formatter doesn't mangle
+    # the actual error message https://github.com/rstudio/rstudio/issues/16365
+    result <- gsub("Error: ", "Compiler Error: ", result, fixed = TRUE)
     writeLines(result, stderr())
-    str(attributes(result))
-    stop("Compilation Error")
+    cat("---\nCompiler exit status:", status, "\n", file = stderr())
+    stop("Compilation Error", call. = FALSE)
   }
 
   # tryCatch(dyn.unload(dll_path), error = identity)

R/r2f.R

@@ -944,6 +944,39 @@ r2f_handlers[["double"]] <- function(args, scope, ...) {
 
 r2f_handlers[["numeric"]] <- r2f_handlers[["double"]]
 
+r2f_handlers[["runif"]] <- function(args, scope, ..., hoist = NULL) {
+  attr(scope, "uses_rng") <- TRUE
+
+  dims <- r2dims(args$n, scope)
+  var <- Variable("double", dims)
+
+  min <- args$min %||% 0
+  max <- args$max %||% 1
+  default_min <- identical(min, 0) || identical(min, 0L)
+  default_max <- identical(max, 1) || identical(max, 1L)
+
+  if (default_min && default_max) {
+    get1rand <- "unif_rand()"
+  } else if (default_min) {
+    max <- r2f(max, scope, ..., hoist = hoist)
+    get1rand <- glue("unif_rand() * {max}")
+  } else {
+    max <- r2f(max, scope, ..., hoist = hoist)
+    min <- r2f(min, scope, ..., hoist = hoist)
+    get1rand <- glue("({min} + (unif_rand() * ({max} - {min})))")
+  }
+
+  if (passes_as_scalar(var)) {
+    fortran <- get1rand
+  } else {
+    tmp_i <- scope@get_unique_var("integer") ## would be better as uint64...
+    fortran <- glue("[({get1rand}, {tmp_i}=1, {dims[[1L]]})]")
+  }
+
+  Fortran(fortran, var)
+}
+
+
 r2f_handlers[["character"]] <- r2f_handlers[["raw"]] <-
   .r2f_handler_not_implemented_yet
 

R/subroutine.R

@@ -102,8 +102,26 @@ new_fortran_subroutine <- function(name, closure, parent = emptyenv()) {
       append(used_iso_bindings) <- "c_ptrdiff_t"
     }
   }
+  if (isTRUE(attr(scope@closure, "uses_rng", TRUE))) {
+    used_iso_bindings <- union(used_iso_bindings, "c_double")
+  }
   used_iso_bindings <- sort(used_iso_bindings, method = "radix")
 
+  uses_rng <- isTRUE(attr(scope, 'uses_rng', TRUE))
+  if (uses_rng) {
+    rng_interface <- glue::trim(
+      '
+      interface
+        function unif_rand() bind(c, name = "unif_rand") result(u)
+          use iso_c_binding, only: c_double
+          real(c_double) :: u
+        end function unif_rand
+      end interface
+      '
+    )
+
+    manifest <- str_flatten_lines(manifest, "", rng_interface)
+  }
   subroutine <- glue(
     "
     subroutine {name}({str_flatten_commas(fsub_arg_names)}) bind(c)

README.Rmd

@@ -364,6 +364,12 @@ plot(timings) + bench::scale_x_bench_time(base = NULL)
 When called in a package, `quick()` will pre-compile the quick functions and place them in the `./src` directory.
 Run `devtools::load_all()` or `quickr::compile_package()` to ensure that the generated files in `./src` and `./R` are in sync with each other.
 
+In a package, you must provide a function name to `quick()`. For example:
+
+```r
+my_fun <- quick(name = "my_fun", function(x) ....)
+```
+
 ## Installation
 
 You can install quickr from CRAN with:

README.md

@@ -3,12 +3,11 @@
 
 # quickr <img src="man/figures/logo.png" align="right" height="138"/>
 
-<!-- <img
-src="https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExMjBhNWt1Z3Q4ZW56cG00c2hncmtwbGJycm53M3JxYWdscjRkaDJobCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/12haGO61oFZ28w/giphy.gif"
-alt="An animated GIF showing two characters in a spaceship cockpit rapidly accelerating into hyperspace, with stars stretching into bright streaks, creating a sensation of rapid acceleration and motion." /> -->
+<!-- ![](https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExMjBhNWt1Z3Q4ZW56cG00c2hncmtwbGJycm53M3JxYWdscjRkaDJobCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/12haGO61oFZ28w/giphy.gif){alt="An animated GIF showing two characters in a spaceship cockpit rapidly accelerating into hyperspace, with stars stretching into bright streaks, creating a sensation of rapid acceleration and motion."} -->
 
 <!-- badges: start -->
 
+[![R-CMD-check](https://github.com/t-kalinowski/quickr/actions/workflows/R-CMD-check.yaml/badge.svg)](https://github.com/t-kalinowski/quickr/actions/workflows/R-CMD-check.yaml)
 <!-- badges: end -->
 
 The goal of quickr is to make your R code run quicker.
@@ -20,11 +19,11 @@ and dynamicism can come at the expense of speed. This package lets you
 trade back some of that flexibility for some speed, for the context of a
 single function.
 
-<!-- Programming language design requires some hard decisions and trade-offs. -->
+<!-- Programming language design requires some hard decisions and trade-ofs. -->
 
 <!-- When you want to have it all, you typically end up have two (or more!) languages. -->
 
-<!-- An interpreted, dynamic language full of conveniences, and a statically‑typed, explicit, high-performance language. -->
+<!-- An interpreted, dynamic language full of conveniences, and a staticly-typed, explicit, high-performance language. -->
 
 <!-- This is sometimes called the "Two Language Problem". -->
 
@@ -138,9 +137,9 @@ timings
 #> # A tibble: 3 × 6
 #>   expression      min   median `itr/sec` mem_alloc `gc/sec`
 #>   <bch:expr> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
-#> 1 r             1.05s    1.05s     0.955     847KB    0.955
-#> 2 quickr        4.8ms   5.09ms   195.        782KB    3.07
-#> 3 c            4.73ms   5.04ms   196.        782KB    3.09
+#> 1 r             1.04s    1.04s     0.957     782KB    0.957
+#> 2 quickr       4.85ms   5.03ms   198.        782KB    3.61 
+#> 3 c            4.88ms   5.06ms   197.        782KB    4.13
 plot(timings) + bench::scale_x_bench_time(base = NULL)
 ```
 
@@ -163,16 +162,17 @@ In the case of `convolve()`, `quick()` returns a function approximately
 
 <!-- -->
 
-    #>  [1] -         :         !=        (         [         [<-       {
-    #>  [8] *         /         &         &&        %/%       %%        ^
-    #> [15] +         <         <-        <=        =         ==        >
-    #> [22] >=        |         ||        Arg       Conj      Fortran   Im
-    #> [29] Mod       Re        abs       acos      asin      atan      c
-    #> [36] cat       cbind     ceiling   character cos       declare   double
-    #> [43] exp       floor     for       if        ifelse    integer   length
-    #> [50] log       log10     logical   matrix    max       min       numeric
-    #> [57] print     prod      raw       seq       sin       sqrt      sum
-    #> [64] tan       which.max which.min
+    #>  [1] -         :         !=        (         [         [<-       {        
+    #>  [8] *         /         &         &&        %/%       %%        ^        
+    #> [15] +         <         <-        <=        =         ==        >        
+    #> [22] >=        |         ||        Arg       Conj      Fortran   Im       
+    #> [29] Mod       Re        abs       acos      as.double asin      atan     
+    #> [36] break     c         cat       cbind     ceiling   character cos      
+    #> [43] declare   dim       double    exp       floor     for       if       
+    #> [50] ifelse    integer   length    log       log10     logical   matrix   
+    #> [57] max       min       ncol      next      nrow      numeric   print    
+    #> [64] prod      raw       repeat    runif     seq       sin       sqrt     
+    #> [71] sum       tan       which.max which.min while
 
 Many of these restrictions are expected to be relaxed as the project
 matures. However, quickr is intended primarily for high-performance
@@ -281,8 +281,8 @@ timings
 #> # A tibble: 2 × 6
 #>   expression         min   median `itr/sec` mem_alloc `gc/sec`
 #>   <bch:expr>    <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
-#> 1 slow_viterbi  143.04µs    162µs     6047.     178KB     14.5
-#> 2 quick_viterbi   2.43µs   2.53µs   368609.        0B      0
+#> 1 slow_viterbi  147.12µs 162.33µs     5957.    1.59KB     16.8
+#> 2 quick_viterbi   2.48µs   2.62µs   367468.        0B      0
 plot(timings)
 ```
 
@@ -360,8 +360,8 @@ summary(timings, relative = TRUE)
 #> # A tibble: 2 × 6
 #>   expression           min median `itr/sec` mem_alloc `gc/sec`
 #>   <bch:expr>         <dbl>  <dbl>     <dbl>     <dbl>    <dbl>
-#> 1 diffuse_heat        127.   122.        1      1014.      Inf
-#> 2 quick_diffuse_heat    1      1       121.        1       NaN
+#> 1 diffuse_heat        131.   127.        1      1011.      Inf
+#> 2 quick_diffuse_heat    1      1       127.        1       NaN
 plot(timings)
 ```
 
@@ -407,9 +407,9 @@ timings
 #> # A tibble: 3 × 6
 #>   expression      min   median `itr/sec` mem_alloc `gc/sec`
 #>   <bch:expr> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
-#> 1 r           105.4ms 109.13ms      7.42  124.31MB    22.3
-#> 2 rcpp         19.7ms  19.84ms     49.4     4.44MB     1.98
-#> 3 quickr          7ms   7.09ms    138.    781.35KB     2.00
+#> 1 r           114.2ms 132.75ms      5.66  124.24MB     9.44
+#> 2 rcpp        19.35ms  19.58ms     50.9     4.44MB     0   
+#> 3 quickr       6.73ms   6.87ms    142.    781.35KB     1.98
 
 timings$expression <- factor(names(timings$expression), rev(names(timings$expression)))
 plot(timings) + bench::scale_x_bench_time(base = NULL)
@@ -424,6 +424,13 @@ and place them in the `./src` directory. Run `devtools::load_all()` or
 `quickr::compile_package()` to ensure that the generated files in
 `./src` and `./R` are in sync with each other.
 
+In a package, you must provide a function name to `quick()`. For
+example:
+
+``` r
+my_fun <- quick(name = "my_fun", function(x) ....)
+```
+
 ## Installation
 
 You can install quickr from CRAN with: