Updated to version 0.1.8 (Under Development)

Author: tony-aw

.Rhistory

@@ -1 +0,0 @@
-setwd("D:/D Desktop/Publications/R package broadcast/broadcast")

DESCRIPTION

@@ -1,12 +1,12 @@
 Package: broadcast
 Title: Broadcasted Array Operations Like 'NumPy'
-Version: 0.1.7
+Version: 0.1.8
 Authors@R: person("Tony", "Wilkes", role = c("aut", "cre", "cph"),
                   email = "tony_a_wilkes@outlook.com",
                   comment = c(ORCID = "0000-0001-9498-8379"))
 Description: Implements efficient 'NumPy'-like broadcasted operations for atomic and recursive arrays.
     In the context of operations involving 2 (or more) arrays,
-    “broadcasting” refers to efficiently recycling array dimensions,
+    “broadcasting” (AKA singleton expansion) refers to efficiently recycling array dimensions,
     without making copies.
 		Besides linking to 'Rcpp',
 		'broadcast' does not use any external libraries in any way;

NAMESPACE

@@ -22,6 +22,8 @@ S3method(cast_dim2flat,default)
 S3method(cast_dim2hier,default)
 S3method(cast_hier2dim,default)
 S3method(cast_shallow2atomic,default)
+S3method(checkNA,default)
+S3method(checkNULL,default)
 S3method(dropnests,default)
 S3method(format,broadcaster)
 S3method(hier2dim,default)
@@ -60,8 +62,11 @@ export(cast_dim2flat)
 export(cast_dim2hier)
 export(cast_hier2dim)
 export(cast_shallow2atomic)
+export(checkNA)
+export(checkNULL)
 export(cinv)
 export(dropnests)
+export(ecumprob)
 export(hier2dim)
 export(hiernames2dimnames)
 export(lst.ndim)

NEWS.md

@@ -1,4 +1,15 @@
 
+# broadcast 0.1.8
+
+* Slightly relaxed the behaviour for `NA`s/`NaN`s for the `+` and `-` operators involving complex numbers.
+* Streamlined some internal code here and there.
+* Changed the internal code to avoid the false-positive issue message in 'Rchk'.
+* Built the package with the recently updated version of 'Rcpp'.
+* Added the `checkNULL()` and `checkNA()` methods.
+* Added a new linear algebra function for statistics: `ecumprob()`.
+
+<br>
+
 # broadcast 0.1.7
 
 **Consistency fixes:**

R/RcppExports.R

@@ -13,6 +13,13 @@
     .Call(`_broadcast_rcpp_address`, x)
 }
 
+#' @keywords internal
+NULL
+
+.rcpp_any_nonarray <- function(x) {
+    .Call(`_broadcast_rcpp_any_nonarray`, x)
+}
+
 #' @keywords internal
 #' @noRd
 .rcpp_bcD_dec_v <- function(x, y, nout, op, prec) {
@@ -532,6 +539,41 @@
 #' @keywords internal
 NULL
 
+#' @keywords internal
+NULL
+
+#' @keywords internal
+NULL
+
+#' @keywords internal
+NULL
+
+#' @keywords internal
+NULL
+
+.rcpp_dimnames_fit <- function(x, dimnames) {
+    .Call(`_broadcast_rcpp_dimnames_fit`, x, dimnames)
+}
+
+.rcpp_make_dimnames2 <- function(xdimnames, ydimnames, outdim, pref) {
+    .Call(`_broadcast_rcpp_make_dimnames2`, xdimnames, ydimnames, outdim, pref)
+}
+
+.rcpp_make_dimnames_between <- function(adimnames, vnames, outdim) {
+    .Call(`_broadcast_rcpp_make_dimnames_between`, adimnames, vnames, outdim)
+}
+
+.rcpp_make_dimnames1 <- function(y_dimnames, ydim, outdim) {
+    .Call(`_broadcast_rcpp_make_dimnames1`, y_dimnames, ydim, outdim)
+}
+
+.rcpp_binames_set <- function(x, y, out) {
+    invisible(.Call(`_broadcast_rcpp_binames_set`, x, y, out))
+}
+
+#' @keywords internal
+NULL
+
 #' @keywords internal
 #' @noRd
 .rcpp_bindhelper_setnames <- function(x, ind, rp) {
@@ -596,6 +638,48 @@ NULL
     invisible(.Call(`_broadcast_rcpp_shallow2atomic`, input, output, nrow, ncol, arrangement))
 }
 
+#' @keywords internal
+#' @noRd
+.rcpp_checkmissing_is_raw <- function(y, invert) {
+    .Call(`_broadcast_rcpp_checkmissing_is_raw`, y, invert)
+}
+
+#' @keywords internal
+#' @noRd
+.rcpp_checkmissing_is_logical <- function(y, invert) {
+    .Call(`_broadcast_rcpp_checkmissing_is_logical`, y, invert)
+}
+
+#' @keywords internal
+#' @noRd
+.rcpp_checkmissing_count <- function(y, invert) {
+    .Call(`_broadcast_rcpp_checkmissing_count`, y, invert)
+}
+
+#' @keywords internal
+#' @noRd
+.rcpp_checkmissing_first <- function(y, invert) {
+    .Call(`_broadcast_rcpp_checkmissing_first`, y, invert)
+}
+
+#' @keywords internal
+#' @noRd
+.rcpp_checkmissing_last <- function(y, invert) {
+    .Call(`_broadcast_rcpp_checkmissing_last`, y, invert)
+}
+
+#' @keywords internal
+#' @noRd
+.rcpp_checkmissing_which32 <- function(y, invert, size) {
+    .Call(`_broadcast_rcpp_checkmissing_which32`, y, invert, size)
+}
+
+#' @keywords internal
+#' @noRd
+.rcpp_checkmissing_which64 <- function(y, invert, size) {
+    .Call(`_broadcast_rcpp_checkmissing_which64`, y, invert, size)
+}
+
 #' @keywords internal
 #' @noRd
 .rcpp_is_ma <- function(x) {
@@ -614,6 +698,20 @@ NULL
     .Call(`_broadcast_rcpp_clone`, x)
 }
 
+#' @keywords internal
+NULL
+
+#' @keywords internal
+NULL
+
+.rcpp_ecp_mat <- function(y, sim, nrow, ncol, eps) {
+    .Call(`_broadcast_rcpp_ecp_mat`, y, sim, nrow, ncol, eps)
+}
+
+.rcpp_ecp_df <- function(y, sim, nrow, ncol, eps) {
+    .Call(`_broadcast_rcpp_ecp_df`, y, sim, nrow, ncol, eps)
+}
+
 #' @keywords internal
 #' @noRd
 .rcpp_depth_range <- function(x, depth_limit, recurse_all) {
@@ -646,44 +744,34 @@ NULL
 
 #' @keywords internal
 #' @noRd
-.rcpp_make_dimnames2 <- function(xdimnames, ydimnames, outdim, pref) {
-    .Call(`_broadcast_rcpp_make_dimnames2`, xdimnames, ydimnames, outdim, pref)
+.rcpp_lst_ndims <- function(x) {
+    .Call(`_broadcast_rcpp_lst_ndims`, x)
 }
 
 #' @keywords internal
-#' @noRd
-.rcpp_make_dimnames_between <- function(adimnames, vnames, outdim) {
-    .Call(`_broadcast_rcpp_make_dimnames_between`, adimnames, vnames, outdim)
-}
+NULL
 
 #' @keywords internal
-#' @noRd
-.rcpp_make_dimnames1 <- function(y_dimnames, ydim, outdim) {
-    .Call(`_broadcast_rcpp_make_dimnames1`, y_dimnames, ydim, outdim)
-}
+NULL
 
 #' @keywords internal
-#' @noRd
-.rcpp_is_mergeable_with_prev <- function(xB, yB) {
-    .Call(`_broadcast_rcpp_is_mergeable_with_prev`, xB, yB)
+NULL
+
+.rcpp_mergedims_get_endrange <- function(x, y, pos, intmax) {
+    .Call(`_broadcast_rcpp_mergedims_get_endrange`, x, y, pos, intmax)
 }
 
-#' @keywords internal
-#' @noRd
-.rcpp_mergedims <- function(xD, yD, mergeable) {
-    .Call(`_broadcast_rcpp_mergedims`, xD, yD, mergeable)
+.rcpp_mergedims_get_prods <- function(x, y, start, end) {
+    .Call(`_broadcast_rcpp_mergedims_get_prods`, x, y, start, end)
 }
 
-#' @keywords internal
-NULL
+.rcpp_mergedims <- function(x, y) {
+    .Call(`_broadcast_rcpp_mergedims`, x, y)
+}
 
 #' @keywords internal
 #' @noRd
 .rcpp_set_attr <- function(x, name, value) {
     invisible(.Call(`_broadcast_rcpp_set_attr`, x, name, value))
 }
 
-.rcpp_dimnames_fit <- function(x, dimnames) {
-    .Call(`_broadcast_rcpp_dimnames_fit`, x, dimnames)
-}
-

R/aaa04_broadcast_linearalgebra.R

@@ -2,24 +2,36 @@
 #'
 #' @description
 #' 'broadcast' provides some simple Linear Algebra Functions for Statistics: \cr
-#' `cinv()`; \cr
-#' `sd_lc()`. \cr
+#' `cinv()` \cr
+#' `sd_lc()` \cr
+#' `ecumprob()` \cr
 #' \cr
 #' \cr
 #' 
 #' @param x a real symmetric positive-definite square matrix.
 #' @param X a numeric (or logical) matrix of multipliers/constants
 #' @param vc the variance-covariance matrix for the (correlated) random variables.
+#' @param y values to estimate the cumulative probability for.
+#' @param sim a matrix (or data.frame) with at least 500 columns of simulated values. \cr
+#' If `sim` is given as a dimensionless vector,
+#' it will be treated as a matrix with 1 row and `length(sim)` columns,
+#' and this will be noted with a message.
+#' @param eps a non-negative numeric scaler smaller than `0.1`,
+#' giving the cut-off value for probabilities. \cr
+#' Probabilities smaller than `eps` will be replaced with `eps`,
+#' and probabilities larger than `1 - eps` will be replaced with `1 - eps`. \cr
+#' Set `eps = 0` to disable probability trimming.
 #' @param bad_rp if `vc` is not a Positive (semi-) Definite matrix,
 #' give here the value to replace bad standard deviations with. \cr \cr
 #' 
 #' @details
-#' \bold{cinv()} \cr
+#' \bold{`cinv()`} \cr
 #' `cinv()`
 #' computes the Choleski inverse
 #' of a real symmetric positive-definite square matrix. \cr
 #' \cr
-#' \bold{sd_lc()} \cr
+#' \cr
+#' \bold{`sd_lc()`} \cr
 #' Given the linear combination `X %*% b`, where:
 #' 
 #'  - `X` is a matrix of multipliers/constants;
@@ -34,16 +46,39 @@
 #' (depending on the Linear Algebra Library used for base 'R'). \cr
 #' \cr
 #' \cr
-#' 
+#' \bold{`ecumprob()`} \cr
+#' The `ecumprod(y, sim)` function takes a matrix (or data.frame) of simulated values `sim`,
+#' and for each row `i` (after broadcasting),
+#' estimates the cumulative distribution function of `sim[i, ]`,
+#' and returns the cumulative probability for `y[i]`. \cr
+#' \cr
+#' In terms of statistics,
+#' it is equivalent to the following operation for each index `i`: \cr
+#' `ecdf(sim[i,])(y[i])` \cr
+#' However, `ecumprob()` is \bold{much} faster, and supports `NA`s/`NaN`s. \cr
+#' \cr
+#' In terms of linear algebra,
+#' it is equivalent to the following broadcasted operation: \cr
+#' `rowMeans(sim <= y)` \cr
+#' where `y` and `sim` are \link{broadcaster} arrays. \cr
+#' However, `ecumprob()` is \bold{much more} memory-efficient,
+#' supports a data.frame for `sim`,
+#' and has statistical safety checks. \cr
+#' \cr
 #' 
 #'
 #' @returns
 #' For `cinv()`: \cr
 #' A matrix. \cr
 #' \cr
 #' For `sd_lc()`: \cr
-#' A vector of standard deviations.
+#' A vector of standard deviations. \cr
 #' \cr
+#' For `ecumprob()`: \cr
+#' A vector of cumulative probabilities. \cr
+#' If for any observation `i` (after broadcasting,) `y[i]` is NA/NaN or any of `sim[i,]` is NA/NaN,
+#' the result for `i` will be `NA`. \cr
+#' If zero-length `y` or `sim` is given, a zero-length numeric vector is returned. \cr
 #' \cr
 #'
 #'

R/bc_cplx.R

@@ -3,17 +3,18 @@
 #' @description
 #' The `bc.cplx()` function performs broadcasted complex numeric operations on pairs of arrays. \cr
 #' \cr
-#' Note that `bc.cplx()` uses more strict `NA` checks than base 'R': \cr
-#' If for an element of either `x` or `y`, either the real or imaginary part is `NA` or `NaN`,
-#' than the result of the operation for that element is necessarily `NA`. \cr
-#' \cr \cr
 #' 
 #' @param x,y conformable vectors/arrays of type `complex`.
 #' @param op a single string, giving the operator. \cr
 #' Supported arithmetic operators: `r paste0(broadcast:::.op_cplx_math(), collapse = ", ")`. \cr
 #' Supported relational operators: `r paste0(broadcast:::.op_cplx_rel(), collapse = ", ")`.
 #' @param ... further arguments passed to or from methods. \cr \cr
 #' 
+#' @details
+#' For the `*` and `/` operators, `bc.cplx()` uses more strict `NA` checks than base 'R': \cr
+#' If for an iteration,
+#' `re(x)`, `im(x)`, `re(y)`, and/or `im(y)` contains `NA`,
+#' than the result for that iteration is necessarily `NA_complex_`.
 #' 
 #'
 #' @returns