code
stringlengths 1
13.8M
|
|---|
mapdeckGeojsonDependency <- function() {
list(
createHtmlDependency(
name = "geojson",
version = "1.0.0",
src = system.file("htmlwidgets/lib/geojson", package = "mapdeck"),
script = c("geojson.js"),
all_files = FALSE
)
)
}
add_geojson <- function(
map,
data = get_map_data(map),
layer_id = NULL,
stroke_colour = NULL,
stroke_opacity = NULL,
stroke_width = NULL,
dash_size = NULL,
dash_gap = NULL,
fill_colour = NULL,
fill_opacity = NULL,
radius = NULL,
elevation = NULL,
extruded = FALSE,
light_settings = list(),
legend = F,
legend_options = NULL,
legend_format = NULL,
auto_highlight = FALSE,
tooltip = NULL,
highlight_colour = "
palette = "viridis",
na_colour = "
line_width_units = c("meters", "pixels"),
line_width_scale = 1,
line_width_min_pixels = 0,
elevation_scale = 1,
point_radius_scale = 1,
point_radius_min_pixels = 1,
update_view = TRUE,
focus_layer = FALSE,
digits = 6,
transitions = NULL
) {
l <- list()
line_width_units <- match.arg(line_width_units)
l[["stroke_colour"]] <- force( stroke_colour )
l[["stroke_opacity"]] <- force( stroke_opacity )
l[["stroke_width"]] <- force( stroke_width )
l[["dash_size"]] <- force(dash_size)
l[["dash_gap"]] <- force(dash_gap)
l[["fill_colour"]] <- force( fill_colour )
l[["fill_opacity"]] <- force( fill_opacity )
l[["elevation"]] <- force( elevation )
l[["radius"]] <- force( radius )
l[["tooltip"]] <- force( tooltip )
l[["na_colour"]] <- force(na_colour)
bbox <- init_bbox()
update_view <- force( update_view )
focus_layer <- force( focus_layer )
if ( any (
!is.null( l[["stroke_colour"]] ) |
!is.null( l[["stroke_opacity"]] ) |
!is.null( l[["stroke_width"]] ) |
!is.null( l[["dash_size"]] ) |
!is.null( l[["dash_gap"]] ) |
!is.null( l[["fill_colour"]] ) |
!is.null( l[["fill_opacity"]] ) |
!is.null( l[["elevation"]] ) |
!is.null( l[["radius"]] )
) ) {
if( inherits( data, "geojson" ) | inherits( data, "json" ) | inherits( data, "character" ) ) {
data <- geojsonsf::geojson_sf( data )
}
}
l <- resolve_palette( l, palette )
l <- resolve_legend( l, legend )
l <- resolve_legend_options( l, legend_options )
l <- resolve_geojson_data( data, l )
line_width_units <- match.arg(line_width_units)
if( !is.null(l[["data"]] ) ) {
data <- l[["data"]]
l[["data"]] <- NULL
}
if( !is.null( l[["bbox"]] ) ) {
bbox <- l[["bbox"]]
l[["bbox"]] <- NULL
}
layer_id <- layerId( layer_id, "geojson" )
tp <- l[["data_type"]]
l[["data_type"]] <- NULL
if( tp == "sf" ) {
shape <- rcpp_geojson_geojson( data, l, "geometry", digits)
jsfunc <- "add_geojson_sf"
} else if ( tp == "geojson" ) {
jsfunc <- "add_geojson"
shape <- list()
shape[["data"]] <- data
}
light_settings <- jsonify::to_json(light_settings, unbox = T)
js_transitions <- resolve_transitions( transitions, "geojson" )
map <- addDependency(map, mapdeckGeojsonDependency())
if( inherits( legend, "json" ) ) {
shape[["legend"]] <- legend
} else {
shape[["legend"]] <- resolve_legend_format( shape[["legend"]], legend_format )
}
invoke_method(
map, jsfunc, map_type( map ), shape[["data"]], layer_id, light_settings, auto_highlight,
highlight_colour, shape[["legend"]], bbox, update_view, focus_layer,
js_transitions, line_width_units, line_width_scale, line_width_min_pixels,
elevation_scale, point_radius_scale, point_radius_min_pixels, extruded
)
}
clear_geojson <- function( map, layer_id = NULL, update_view = TRUE ) {
layer_id <- layerId(layer_id, "geojson")
invoke_method(map, "md_layer_clear", map_type( map ), layer_id, "geojson", update_view )
}
|
parUpdate <-
function(cl, object, n.iter = 1, ...)
{
requireNamespace("rjags")
cl <- evalParallelArgument(cl, quit=TRUE)
if (!inherits(cl, "cluster"))
stop("cl must be of class 'cluster'")
clusterEvalQ(cl, requireNamespace("rjags"))
if (!is.character(object))
object <- as.character(object)
cldata <- list(n.iter=n.iter, name=object)
jagsparallel <- function(i, ...) {
cldata <- pullDcloneEnv("cldata", type = "model")
if (existsDcloneEnv(cldata$name, type = "results")) {
res <- pullDcloneEnv(cldata$name,
type = "results")
update(object=res, n.iter=cldata$n.iter, ...)
pushDcloneEnv(cldata$name, res, type = "results")
}
NULL
}
parDosa(cl, 1:length(cl), jagsparallel, cldata,
lib = c("dclone", "rjags"), balancing = "none", size = 1,
rng.type = getOption("dcoptions")$RNG,
cleanup = TRUE,
dir = NULL,
unload = FALSE, ...)
}
|
expected <- eval(parse(text="-0.133986975078774"));
test(id=0, code={
argv <- eval(parse(text="list(-0.133190890463189)"));
do.call(`atanh`, argv);
}, o=expected);
|
unlink(test_path("dir_code/.binder"), recursive = TRUE)
|
calibrate.BlackCox <- function(V0, cdsrate, r, t, ...){
if(!is.numeric(V0)) stop("V0 must be a number")
if(length(V0) != 1) stop("V0 must be a number and not a vector")
if(!is.numeric(r)) stop("r must be a number")
if(length(r) != 1) stop("r must be constant for all maturities")
if(!is.numeric(cdsrate)) stop("cdsrate must be a numeric vector")
if(!is.numeric(t)) stop("Time t must be a numeric vector")
if(length(cdsrate) != length(t)) stop("cdsrate and t must have the same length")
objfn <- function(par, cdsrate, r, t){
L <- par[1]
K <- par[1] - par[2]
sigma <- abs(par[3])
gamma <- par[4]
intensity <- BlackCox(L = L, K = K, V0 = V0, sigma = sigma, r = r, gamma = gamma, t = t)$Default.Intensity
rate <- cds(t = t, int = intensity, r = r, ...)$Rate
err <- mean((rate - cdsrate)^2)
return(err)
}
par <- c(V0/2, (0.15 * V0/2), 0.2, 0.08)
out <- stats::optim(par = par, fn = objfn, cdsrate = cdsrate, t = t, r = r, method = 'L-BFGS-B', lower = 0 * t)
out <- c(V0, par[1], (par[1] - par[2]), abs(out$par[3]), out$par[4], out$value)
names(out) <- c('V0', 'L', 'K', 'sigma', 'gamma', 'Error')
return(data.frame(t(out)))
}
|
\dontrun{
library(listviewer)
library(reactR)
reactjson()
reactjson(head(mtcars,4))
reactjson(I(jsonlite::toJSON(head(mtcars,5))))
library(shiny)
shinyApp(
ui = reactjson(
list(x=1,msg="react+r+shiny",opts=list(use_react=FALSE)),
elementId = "json1"
),
server = function(input, output, session){
observeEvent(
input$json1_change,
str(input$json1_change)
)
}
)
library(miniUI)
ui <- miniUI::miniPage(
miniUI::miniContentPanel(
reactjson(
list(x=1,msg="react+r+shiny",opts=list(use_react=FALSE)),
elementId = "rjeditor"
)
),
miniUI::gadgetTitleBar(
"Edit",
right = miniUI::miniTitleBarButton("done", "Done", primary = TRUE)
)
)
server <- function(input, output, session) {
shiny::observeEvent(input$done, {
shiny::stopApp(
input$rjeditor_change
)
})
shiny::observeEvent(input$cancel, { shiny::stopApp (NULL) })
}
runGadget(
ui,
server,
viewer = shiny::paneViewer()
)
}
|
fixedGlmer <-
function(model,observ,fam_link) {
rand_terms<- sapply(findbars(formula(model)),function(x) paste0("(", deparse(x), ")"))
drop_form<- list()
resp_term<- sapply(nobars(formula(model)),function(x) deparse(x))[2]
fixed_terms<- paste(attributes(terms(model))$term.labels)
ftable<- data.frame(term=fixed_terms)
ftable$d.AIC<- NA;ftable$d.BIC<- NA;ftable$Chi.sq<- NA; ftable$p.value<- NA
for (i in 1:length(fixed_terms)) {
drop_form[[i]] <- reformulate(c(rand_terms,fixed_terms[-i]),response=resp_term)
m_new<- glmer(formula=drop_form[[i]],family=fam_link,data=observ)
p_mod<- anova(model,m_new)
ftable[,-1][i,]<-c(p_mod$AIC[1]-p_mod$AIC[2],p_mod$BIC[1]-p_mod$BIC[2],p_mod$Chisq[2],p_mod$'Pr(>Chisq)'[2]) }
invisible(ftable)
}
|
lrt2.org <- function(PV.gbd, CLASS.gbd, K, H0.mean = 0.05,
upper.beta = .FC.CT$INIT$BETA.beta.max){
if((H0.mean <= 0) || (H0.mean >= 0.5)){
stop("It should be 0 < H0.mean < 0.5.")
}
K.CLASS <- as.integer(max.gbd(CLASS.gbd))
if(K.CLASS > K){
stop("CLASS.gbd and K are not matched.")
}
beta.scale <- H0.mean / (1 - H0.mean)
fn.H0 <- function(theta, x.gbd){
-sum.gbd(dbeta(x.gbd, beta.scale * theta[1], theta[1], log = TRUE))
}
fn.Ha <- function(theta, x.gbd){
-sum.gbd(dbeta(x.gbd, theta[1], theta[2], log = TRUE))
}
ui.Ha <- rbind(c(1, 0), c(H0.mean - 1, H0.mean))
ci.Ha <- c(0, 0)
ret <- NULL
for(i.k in 1:K){
N.class.gbd <- sum.gbd(CLASS.gbd == i.k)
if(N.class.gbd > 0){
tmp.gbd <- PV.gbd[CLASS.gbd == i.k]
tmp <- optim(c(1.01), fn.H0, NULL, x.gbd = tmp.gbd,
method = "Brent", lower = 0, upper = upper.beta)
H0.beta <- tmp$par[1]
H0.alpha <- beta.scale * H0.beta
logL.0 <- -tmp$value
tmp <- constrOptim(c(beta.scale * 0.99, 1.01), fn.Ha, NULL, ui.Ha, ci.Ha,
method = "Nelder-Mead", x.gbd = tmp.gbd)
Ha.alpha <- tmp$par[1]
Ha.beta <- tmp$par[2]
logL.a <- -tmp$value
lrt <- -2 * (logL.0 - logL.a)
if(lrt < 0){
lrt <- 0
}
p.value <- pchisq(lrt, 1, lower.tail = FALSE)
ret <- rbind(ret, c(i.k, H0.beta, Ha.alpha, Ha.beta,
logL.0, logL.a, lrt, p.value))
} else{
ret <- rbind(ret, c(i.k, rep(NA, 7)))
}
}
colnames(ret) <- c("i.k", "mle.0.beta",
"mle.a.alpha", "mle.a.beta",
"logL.0", "logL.a", "lrt", "p.value")
ret
}
|
map_ggmap <- function(...) .Defunct()
|
myALS_SVD <- function(Xn, k, L2=1e-10, iter=30){
nr <- nrow(Xn)
nc <- ncol(Xn)
U <- .normMat(matrix(runif(nr*k), nrow=nr, ncol=k), "column")
V <- .normMat(matrix(runif(k*nc), nrow=k, ncol=nc), "row")
for(i in seq(iter)){
U <- .normMat(Xn %*% t(V) %*% ginv(V %*% t(V) + diag(L2, k, k)),
"column")
V <- ginv(t(U) %*% U + diag(L2, k, k)) %*% t(U) %*% Xn
}
U
}
|
NULL
marketplaceentitlementservice <- function(config = list()) {
svc <- .marketplaceentitlementservice$operations
svc <- set_config(svc, config)
return(svc)
}
.marketplaceentitlementservice <- list()
.marketplaceentitlementservice$operations <- list()
.marketplaceentitlementservice$metadata <- list(
service_name = "entitlement.marketplace",
endpoints = list("*" = list(endpoint = "entitlement.marketplace.{region}.amazonaws.com", global = FALSE), "cn-*" = list(endpoint = "entitlement.marketplace.{region}.amazonaws.com.cn", global = FALSE), "us-iso-*" = list(endpoint = "entitlement.marketplace.{region}.c2s.ic.gov", global = FALSE), "us-isob-*" = list(endpoint = "entitlement.marketplace.{region}.sc2s.sgov.gov", global = FALSE)),
service_id = "Marketplace Entitlement Service",
api_version = "2017-01-11",
signing_name = "aws-marketplace",
json_version = "1.1",
target_prefix = "AWSMPEntitlementService"
)
.marketplaceentitlementservice$service <- function(config = list()) {
handlers <- new_handlers("jsonrpc", "v4")
new_service(.marketplaceentitlementservice$metadata, handlers, config)
}
|
FixedN5Cats <- function(kappa0, n, props, raters=2, alpha=0.05)
{
if ( (raters != 1) && (raters !=2) && (raters !=3) && (raters != 4) && (raters != 5) && (raters != 6) )
stop("Sorry, this function is designed for between 2 to 6 raters.")
if (length(props) != 5)
stop("Sorry, you must enter the anticipated proportions of each of the five categories.")
if ( abs( sum(props) - 1) >= 0.001 )
stop("Sorry, the three proportions must sum to one.")
for (i in 1:5)
{
if ((props[i] >= 1) || (props[i] <= 0) )
stop("Sorry, the proportion, props must lie within (0,1).")
}
if ((kappa0 >= 1) || (kappa0 <= 0) )
stop("Sorry, the null value of kappa must lie within (0,1).")
if (n <=10)
stop("Sorry, your study should enroll at least 10 subjects.")
if ( (alpha >= 1) || (alpha <= 0) )
stop("Sorry, the alpha and power must lie within (0,1).")
X <- NULL;
X$kappa0 <- kappa0;
X$n <- n;
X$props <- props;
X$raters <- raters;
X$alpha <- alpha;
X$ChiCrit <- qchisq((1-2*alpha),1);
if (raters == 2)
{
.CalcIT <- function(rho0, rho1, Pi, n)
{
P1 <- function(k, p)
{
x <- p[1]^2*(-(-p[1]-k+k*p[1])/p[1])
return(x)
}
P2 <- function(k, p)
{
x <- p[2]^2*(-(-p[2]-k+k*p[2])/p[2])
return(x)
}
P3 <- function(k, p)
{
x <- p[3]^2*(-(-p[3]-k+k*p[3])/p[3])
}
P4 <- function(k, p)
{
x <- p[4]^2*(-(-p[4]-k+k*p[4])/p[4])
}
P5 <- function(k, p)
{
x <- p[5]^2*(-(-p[5]-k+k*p[5])/p[5])
}
P0 <- function(k, p)
{
x <- 1 - P1(k,p) - P2(k,p) - P3(k,p) -P4(k,p) - P5(k,p);
return(x)
}
results <- c(0,0,0,0,0,0);
results[1] <- ( (n*P0(k=rho0, p=Pi)) - (n*P0(k=rho1, p = Pi)) )^2/ (n*P0(k=rho1, p = Pi))
results[2] <- ( (n*P1(k=rho0, p=Pi)) - (n*P1(k=rho1, p = Pi)) )^2/ (n*P1(k=rho1, p = Pi))
results[3] <- ( (n*P2(k=rho0, p=Pi)) - (n*P2(k=rho1, p = Pi)) )^2/ (n*P2(k=rho1, p = Pi))
results[4] <- ( (n*P3(k=rho0, p=Pi)) - (n*P3(k=rho1, p = Pi)) )^2/ (n*P3(k=rho1, p = Pi))
results[5] <- ( (n*P4(k=rho0, p=Pi)) - (n*P4(k=rho1, p = Pi)) )^2/ (n*P4(k=rho1, p = Pi))
results[6] <- ( (n*P5(k=rho0, p=Pi)) - (n*P5(k=rho1, p = Pi)) )^2/ (n*P5(k=rho1, p = Pi))
return(sum(results,na.rm=TRUE))
}
}
if (raters == 3)
{
.CalcIT <- function(rho0, rho1, Pi, n)
{
P1 <- function(k, p)
{
x <- p[1]^3*((p[1]^2+3*k*p[1]-2*k*p[1]^2+2*k^2-3*k^2*p[1]+k^2*p[1]^2)/p[1]^2)/(1+k)
return(x)
}
P2 <- function(k, p)
{
x <- p[2]^3*((p[2]^2+3*k*p[2]-2*k*p[2]^2+2*k^2-3*k^2*p[2]+k^2*p[2]^2)/p[2]^2)/(1+k)
return(x)
}
P3 <- function(k, p)
{
x <- p[3]^3*((p[3]^2+3*k*p[3]-2*k*p[3]^2+2*k^2-3*k^2*p[3]+k^2*p[3]^2)/p[3]^2)/(1+k)
return(x)
}
P4 <- function(k, p)
{
x <- p[4]^3*((p[4]^2+3*k*p[4]-2*k*p[4]^2+2*k^2-3*k^2*p[4]+k^2*p[4]^2)/p[4]^2)/(1+k)
return(x)
}
P5 <- function(k, p)
{
x <- p[5]^3*((p[5]^2+3*k*p[5]-2*k*p[5]^2+2*k^2-3*k^2*p[5]+k^2*p[5]^2)/p[5]^2)/(1+k)
return(x)
}
P0 <- function(k, p)
{
x <- 1 - P1(k,p) - P2(k,p) - P3(k,p) -P4(k,p) - P5(k,p);
return(x)
}
results <- c(0,0,0,0,0,0);
results[1] <- ( (n*P0(k=rho0, p=Pi)) - (n*P0(k=rho1, p = Pi)) )^2/ (n*P0(k=rho1, p = Pi))
results[2] <- ( (n*P1(k=rho0, p=Pi)) - (n*P1(k=rho1, p = Pi)) )^2/ (n*P1(k=rho1, p = Pi))
results[3] <- ( (n*P2(k=rho0, p=Pi)) - (n*P2(k=rho1, p = Pi)) )^2/ (n*P2(k=rho1, p = Pi))
results[4] <- ( (n*P3(k=rho0, p=Pi)) - (n*P3(k=rho1, p = Pi)) )^2/ (n*P3(k=rho1, p = Pi))
results[5] <- ( (n*P4(k=rho0, p=Pi)) - (n*P4(k=rho1, p = Pi)) )^2/ (n*P4(k=rho1, p = Pi))
results[6] <- ( (n*P5(k=rho0, p=Pi)) - (n*P5(k=rho1, p = Pi)) )^2/ (n*P5(k=rho1, p = Pi))
return(sum(results,na.rm=TRUE))
}
}
if (raters == 4)
{
.CalcIT <- function(rho0, rho1, Pi, n)
{
P1 <- function(k, p)
{
x <- -p[1]*(-p[1]^3-6*k*p[1]^2+3*k*p[1]^3-11*k^2*p[1]+12*k^2*p[1]^2-3*k^2*p[1]^3-6*k^3+11*k^3*p[1]-6*k^3*p[1]^2+k^3*p[1]^3)/((1+k)*(1+2*k))
return(x)
}
P2 <- function(k, p)
{
x <- -p[2]*(-p[2]^3-6*k*p[2]^2+3*k*p[2]^3-11*k^2*p[2]+12*k^2*p[2]^2-3*k^2*p[2]^3-6*k^3+11*k^3*p[2]-6*k^3*p[2]^2+k^3*p[2]^3)/((1+k)*(1+2*k))
return(x)
}
P3 <- function(k, p)
{
x <- -p[3]*(-p[3]^3-6*k*p[3]^2+3*k*p[3]^3-11*k^2*p[3]+12*k^2*p[3]^2-3*k^2*p[3]^3-6*k^3+11*k^3*p[3]-6*k^3*p[3]^2+k^3*p[3]^3)/((1+k)*(1+2*k))
return(x)
}
P4 <- function(k, p)
{
x <- -p[4]*(-p[4]^3-6*k*p[4]^2+3*k*p[4]^3-11*k^2*p[4]+12*k^2*p[4]^2-3*k^2*p[4]^3-6*k^3+11*k^3*p[4]-6*k^3*p[4]^2+k^3*p[4]^3)/((1+k)*(1+2*k))
return(x)
}
P5 <- function(k, p)
{
x <- -p[5]*(-p[5]^3-6*k*p[5]^2+3*k*p[5]^3-11*k^2*p[5]+12*k^2*p[5]^2-3*k^2*p[5]^3-6*k^3+11*k^3*p[5]-6*k^3*p[5]^2+k^3*p[5]^3)/((1+k)*(1+2*k))
return(x)
}
P0 <- function(k, p)
{
x <- 1 - P1(k,p) - P2(k,p) - P3(k,p) - P4(k,p) - P5(k,p);
return(x)
}
results <- c(0,0,0,0,0,0);
results[1] <- ( (n*P0(k=rho0, p=Pi)) - (n*P0(k=rho1, p = Pi)) )^2/ (n*P0(k=rho1, p = Pi))
results[2] <- ( (n*P1(k=rho0, p=Pi)) - (n*P1(k=rho1, p = Pi)) )^2/ (n*P1(k=rho1, p = Pi))
results[3] <- ( (n*P2(k=rho0, p=Pi)) - (n*P2(k=rho1, p = Pi)) )^2/ (n*P2(k=rho1, p = Pi))
results[4] <- ( (n*P3(k=rho0, p=Pi)) - (n*P3(k=rho1, p = Pi)) )^2/ (n*P3(k=rho1, p = Pi))
results[5] <- ( (n*P4(k=rho0, p=Pi)) - (n*P4(k=rho1, p = Pi)) )^2/ (n*P4(k=rho1, p = Pi))
results[6] <- ( (n*P5(k=rho0, p=Pi)) - (n*P5(k=rho1, p = Pi)) )^2/ (n*P5(k=rho1, p = Pi))
return(sum(results,na.rm=TRUE))
}
}
if (raters == 5)
{
.CalcIT <- function(rho0, rho1, Pi, n)
{
P1 <- function(k, p)
{
x <- p[1]*(p[1]^4+10*k*p[1]^3-4*k*p[1]^4+35*k^2*p[1]^2-30*k^2*p[1]^3+6*k^2*p[1]^4+50*k^3*p[1]-70*k^3*p[1]^2+30*k^3*p[1]^3-4*k^3*p[1]^4+24*k^4-50*k^4*p[1]+35*k^4*p[1]^2-10*k^4*p[1]^3+k^4*p[1]^4)/((1+k)*(1+2*k)*(1+3*k))
return(x)
}
P2 <- function(k, p)
{
x <- p[2]*(p[2]^4+10*k*p[2]^3-4*k*p[2]^4+35*k^2*p[2]^2-30*k^2*p[2]^3+6*k^2*p[2]^4+50*k^3*p[2]-70*k^3*p[2]^2+30*k^3*p[2]^3-4*k^3*p[2]^4+24*k^4-50*k^4*p[2]+35*k^4*p[2]^2-10*k^4*p[2]^3+k^4*p[2]^4)/((1+k)*(1+2*k)*(1+3*k))
return(x)
}
P3 <- function(k, p)
{
x <- p[3]*(p[3]^4+10*k*p[3]^3-4*k*p[3]^4+35*k^2*p[3]^2-30*k^2*p[3]^3+6*k^2*p[3]^4+50*k^3*p[3]-70*k^3*p[3]^2+30*k^3*p[3]^3-4*k^3*p[3]^4+24*k^4-50*k^4*p[3]+35*k^4*p[3]^2-10*k^4*p[3]^3+k^4*p[3]^4)/((1+k)*(1+2*k)*(1+3*k))
return(x)
}
P4 <- function(k, p)
{
x <- p[4]*(p[4]^4+10*k*p[4]^3-4*k*p[4]^4+35*k^2*p[4]^2-30*k^2*p[4]^3+6*k^2*p[4]^4+50*k^3*p[4]-70*k^3*p[4]^2+30*k^3*p[4]^3-4*k^3*p[4]^4+24*k^4-50*k^4*p[4]+35*k^4*p[4]^2-10*k^4*p[4]^3+k^4*p[4]^4)/((1+k)*(1+2*k)*(1+3*k))
return(x)
}
P5 <- function(k, p)
{
x <- p[5]*(p[5]^4+10*k*p[5]^3-4*k*p[5]^4+35*k^2*p[5]^2-30*k^2*p[5]^3+6*k^2*p[5]^4+50*k^3*p[5]-70*k^3*p[5]^2+30*k^3*p[5]^3-4*k^3*p[5]^4+24*k^4-50*k^4*p[5]+35*k^4*p[5]^2-10*k^4*p[5]^3+k^4*p[5]^4)/((1+k)*(1+2*k)*(1+3*k))
return(x)
}
P0 <- function(k, p)
{
x <- 1 - P1(k,p) - P2(k,p) - P3(k,p) - P4(k,p) - P5(k,p);
return(x)
}
results <- c(0,0,0,0,0,0);
results[1] <- ( (n*P0(k=rho0, p=Pi)) - (n*P0(k=rho1, p = Pi)) )^2/ (n*P0(k=rho1, p = Pi))
results[2] <- ( (n*P1(k=rho0, p=Pi)) - (n*P1(k=rho1, p = Pi)) )^2/ (n*P1(k=rho1, p = Pi))
results[3] <- ( (n*P2(k=rho0, p=Pi)) - (n*P2(k=rho1, p = Pi)) )^2/ (n*P2(k=rho1, p = Pi))
results[4] <- ( (n*P3(k=rho0, p=Pi)) - (n*P3(k=rho1, p = Pi)) )^2/ (n*P3(k=rho1, p = Pi))
results[5] <- ( (n*P4(k=rho0, p=Pi)) - (n*P4(k=rho1, p = Pi)) )^2/ (n*P4(k=rho1, p = Pi))
results[6] <- ( (n*P5(k=rho0, p=Pi)) - (n*P5(k=rho1, p = Pi)) )^2/ (n*P5(k=rho1, p = Pi))
return(sum(results,na.rm=TRUE))
}
}
if (raters == 6)
{
.CalcIT <- function(rho0, rho1, Pi, n)
{
P1 <- function(k, p)
{
x <- -p[1]*(-p[1]^5-15*k*p[1]^4+5*k*p[1]^5-85*k^2*p[1]^3-10*k^2*p[1]^5+60*k^2*p[1]^4-225*k^3*p[1]^2-90*k^3*p[1]^4+255*k^3*p[1]^3+10*k^3*p[1]^5-274*k^4*p[1]-255*k^4*p[1]^3-5*k^4*p[1]^5+450*k^4*p[1]^2+60*k^4*p[1]^4-120*k^5+274*k^5*p[1]-225*k^5*p[1]^2+85*k^5*p[1]^3-15*k^5*p[1]^4+k^5*p[1]^5)/((1+k)*(1+2*k)*(1+3*k)*(1+4*k))
return(x)
}
P2 <- function(k, p)
{
x <- -p[2]*(-p[2]^5-15*k*p[2]^4+5*k*p[2]^5-85*k^2*p[2]^3+60*k^2*p[2]^4-10*k^2*p[2]^5-225*k^3*p[2]^2+10*k^3*p[2]^5+255*k^3*p[2]^3-90*k^3*p[2]^4-274*k^4*p[2]-5*k^4*p[2]^5+60*k^4*p[2]^4+450*k^4*p[2]^2-255*k^4*p[2]^3-120*k^5+274*k^5*p[2]-225*k^5*p[2]^2+85*k^5*p[2]^3-15*k^5*p[2]^4+k^5*p[2]^5)/((1+k)*(1+2*k)*(1+3*k)*(1+4*k))
return(x)
}
P3 <- function(k, p)
{
x <- -p[3]*(-p[3]^5-15*k*p[3]^4+5*k*p[3]^5-85*k^2*p[3]^3-10*k^2*p[3]^5+60*k^2*p[3]^4-225*k^3*p[3]^2-90*k^3*p[3]^4+255*k^3*p[3]^3+10*k^3*p[3]^5-274*k^4*p[3]-255*k^4*p[3]^3-5*k^4*p[3]^5+450*k^4*p[3]^2+60*k^4*p[3]^4-120*k^5+274*k^5*p[3]-225*k^5*p[3]^2+85*k^5*p[3]^3-15*k^5*p[3]^4+k^5*p[3]^5)/((1+k)*(1+2*k)*(1+3*k)*(1+4*k))
return(x)
}
P4 <- function(k, p)
{
x <- -p[4]*(-p[4]^5-15*k*p[4]^4+5*k*p[4]^5-85*k^2*p[4]^3-10*k^2*p[4]^5+60*k^2*p[4]^4-225*k^3*p[4]^2-90*k^3*p[4]^4+255*k^3*p[4]^3+10*k^3*p[4]^5-274*k^4*p[4]-255*k^4*p[4]^3-5*k^4*p[4]^5+450*k^4*p[4]^2+60*k^4*p[4]^4-120*k^5+274*k^5*p[4]-225*k^5*p[4]^2+85*k^5*p[4]^3-15*k^5*p[4]^4+k^5*p[4]^5)/((1+k)*(1+2*k)*(1+3*k)*(1+4*k))
return(x)
}
P5 <- function(k, p)
{
x <- -p[5]*(-p[5]^5-15*k*p[5]^4+5*k*p[5]^5-85*k^2*p[5]^3-10*k^2*p[5]^5+60*k^2*p[5]^4-225*k^3*p[5]^2-90*k^3*p[5]^4+255*k^3*p[5]^3+10*k^3*p[5]^5-274*k^4*p[5]-255*k^4*p[5]^3-5*k^4*p[5]^5+450*k^4*p[5]^2+60*k^4*p[5]^4-120*k^5+274*k^5*p[5]-225*k^5*p[5]^2+85*k^5*p[5]^3-15*k^5*p[5]^4+k^5*p[5]^5)/((1+k)*(1+2*k)*(1+3*k)*(1+4*k))
return(x)
}
P0 <- function(k, p)
{
x <- 1 - P1(k,p) - P2(k,p) - P3(k,p) - P4(k,p) - P5(k,p);
return(x)
}
results <- c(0,0,0,0,0,0);
results[1] <- ( (n*P0(k=rho0, p=Pi)) - (n*P0(k=rho1, p = Pi)) )^2/ (n*P0(k=rho1, p = Pi))
results[2] <- ( (n*P1(k=rho0, p=Pi)) - (n*P1(k=rho1, p = Pi)) )^2/ (n*P1(k=rho1, p = Pi))
results[3] <- ( (n*P2(k=rho0, p=Pi)) - (n*P2(k=rho1, p = Pi)) )^2/ (n*P2(k=rho1, p = Pi))
results[4] <- ( (n*P3(k=rho0, p=Pi)) - (n*P3(k=rho1, p = Pi)) )^2/ (n*P3(k=rho1, p = Pi))
results[5] <- ( (n*P4(k=rho0, p=Pi)) - (n*P4(k=rho1, p = Pi)) )^2/ (n*P4(k=rho1, p = Pi))
results[6] <- ( (n*P5(k=rho0, p=Pi)) - (n*P5(k=rho1, p = Pi)) )^2/ (n*P5(k=rho1, p = Pi))
return(sum(results,na.rm=TRUE))
}
}
rhol <- kappa0;
resultsl <- 0;
while (abs(resultsl - 0.001) < X$ChiCrit)
{
rhol <- rhol - 0.001;
resultsl <- .CalcIT(rho0=kappa0, rho1 = rhol, Pi=props, n=n)
}
X$kappaL <- rhol;
class(X) <- "FixedN5Cats";
return(X);
}
print.FixedN5Cats <- function(x, ...)
{
cat("A total of ", x$n, " subjects can produce a lower limit for kappa of ", x$kappaL, ". \n", sep="")
for (i in 1:length(x$props))
{
if (x$props[i] * x$n < 5)
{
cat("Warning: At least one expected cell count is less than five. \n")
}
}
}
summary.FixedN5Cats <- function(object, ...)
{
cat("Lower Expected Limit for Studies of \n")
cat("Interobserver Agreement for Fixed N \n \n")
cat("Assuming:", "\n")
cat("Kappa0:", object$kappa0, "\n")
cat("N:", object$n, "\n")
cat("Event Proportion:", object$props, "\n")
cat("Number of Raters:", object$raters, "\n")
cat("Type I Error Rate (alpha) = ", object$alpha, "\n \n")
cat("A total of ", object$n, " subjects can produce an expected lower limit for kappa of ", object$kappaL, ". \n \n", sep="")
for (i in 1:length(object$props))
{
if (object$props[i] * object$n < 5)
{
cat("Warning: At least one expected cell count is less than five. \n")
}
}
}
|
library("mboost")
data("birds", package = "TH.data")
bcr <- boost_control(mstop=200, trace=TRUE)
fm <- SG5 ~ bols(GST) + bols(DBH) + bols(AOT) + bols(AFS) + bols(DWC) +
bols(LOG)
sp <- gamboost(fm, data = birds, family = Poisson(), control = bcr)
birdsaic <- AIC(sp, "classical")
plot(birdsaic)
ms <- mstop(birdsaic)
table(sp$xselect()[1:ms])
coef(sp[ms])
bcr <- boost_control(mstop=500, trace=TRUE)
fm <- SG4 ~ bols(GST) + bols(DBH) + bols(AOT) + bols(AFS) + bols(DWC) +
bols(LOG)
sp <- gamboost(fm, data = birds, family = Poisson(), control = bcr)
table(sp$xselect())
coef(sp, which=1:6)
fm <- SG4 ~ bols(GST) + bols(DBH) + bols(AOT) + bols(AFS) + bols(DWC) +
bols(LOG) + bspatial(x_gk, y_gk, df=5, differences=1, knots=c(12,12))
sp <- gamboost(fm, data = birds, family = Poisson(), control = bcr)
table(sp$xselect())
coef(sp, which=1:6)
fm <- SG4 ~ bols(GST) + bols(DBH) + bols(AOT) + bols(AFS) + bols(DWC) +
bols(LOG) + bspatial(x_gk, y_gk, df=1, differences=1, knots=c(12,12), center=TRUE)
sp <- gamboost(fm, data = birds, family = Poisson(), control = bcr)
table(sp$xselect())
coef(sp, which=1:6)
fm <- SG5 ~ bbs(GST) + bbs(DBH) + bbs(AOT) + bbs(AFS) + bbs(DWC) +
bbs(LOG) + bspatial(x_gk, y_gk, df=4, differences=1, knots=c(12,12))
sp <- gamboost(fm, data = birds, family = Poisson(), control = bcr)
plot(sp)
fm <- SG5 ~ bols(GST) + bbs(GST, df=1, center=TRUE) +
bols(AOT) + bbs(AOT, df=1, center=TRUE) +
bols(AFS) + bbs(AFS, df=1, center=TRUE) +
bols(DWC) + bbs(DWC, df=1, center=TRUE) +
bols(LOG) + bbs(LOG, df=1, center=TRUE) +
bspatial(x_gk, y_gk, df=1, differences=1, knots=c(12,12),
center=TRUE)
sp <- gamboost(fm, data = birds, family = Poisson(), control = bcr)
plot(sp)
bcr <- boost_control(mstop=200, trace=TRUE)
birds$GST <- (birds$GST-min(birds$GST))/(max(birds$GST)-min(birds$GST))
birds$AOT <- (birds$AOT-min(birds$AOT))/(max(birds$AOT)-min(birds$AOT))
birds$AFS <- (birds$AFS-min(birds$AFS))/(max(birds$AFS)-min(birds$AFS))
birds$DWC <- (birds$DWC-min(birds$DWC))/(max(birds$DWC)-min(birds$DWC))
birds$LOG <- (birds$LOG-min(birds$LOG))/(max(birds$LOG)-min(birds$LOG))
fm <- SG5 ~ bols(GST) + bspatial(x_gk, y_gk, by = GST, df=1, differences=1,
knots=c(12, 12), center=TRUE) +
bols(AOT) + bspatial(x_gk, y_gk, by = AOT, df=1, differences=1,
knots=c(12, 12), center=TRUE) +
bols(AFS) + bspatial(x_gk, y_gk, by = AFS, df=1, differences=1,
knots=c(12, 12), center=TRUE) +
bols(DWC) + bspatial(x_gk, y_gk, by = DWC, df=1, differences=1,
knots=c(12, 12), center=TRUE) +
bols(LOG) + bspatial(x_gk, y_gk, by = LOG, df=1, differences=1,
knots=c(12, 12), center=TRUE) +
bspatial(x_gk, y_gk, df=1, differences=1, knots=c(12, 12),
center=TRUE)
sp <- gamboost(fm, data = birds, family = Poisson(), control = bcr)
plot(sp, which = "GST")
plot(sp, which = "AOT")
plot(sp, which = "AFS")
plot(sp, which = "DWC")
plot(sp, which = "LOG")
|
if (require("testthat")) {
test_that("describe_distribution", {
x <- describe_distribution(rnorm(100))
expect_equal(c(nrow(x), ncol(x)), c(1, 9))
})
}
|
"call_cccp2" <- function(op, X=NULL, opt, quiet=FALSE){
if(class(op$f)=="ratioFun" && op$max){
stop("Rational functions can only be minimized with solver='cccp2'.\n")
}
if(class(op$f)=="quadFun" && op$max){
stop("Quadratic functions can only be minimized with solver='cccp2'.\n")
}
if(length(op$qc)==0){
stop("There are no quadratic or rational constraints, so use solver='cccp' instead.\n")
}
if(!("abstol" %in% names(opt))){opt$abstol = (1e-06)*(10^length(op$qc)) }
if(!("feastol" %in% names(opt))){opt$feastol = 1e-05}
if(!("trace" %in% names(opt))){opt$trace = !quiet}
if(!("stepadj" %in% names(opt))){opt$stepadj = ifelse(class(op$f)=="ratioFun",0.40, 0.90)}
if(!("maxiters" %in% names(opt))){opt$maxiters = 100L}
if(!("reltol" %in% names(opt))){opt$reltol = 1e-06}
if(!("beta" %in% names(opt))){opt$beta = 0.5}
storage.mode(opt$maxiters) <- "integer"
params.opt <- c("maxiters", "abstol", "reltol", "feastol", "stepadj", "beta", "trace")
opt <- opt[intersect(names(opt), params.opt)]
optctrl<- do.call(cccp::ctrl, opt)
if(!quiet){
cat("\n")
cat("Using solver 'cccp2' with parameters: \n")
print(data.frame(Value=as.character(rapply(opt,c)),row.names=names(rapply(opt,c))))
cat("\n")
}
if(length(op$lb$val)>0 || length(op$ub$val)>0){
op <- bounds2lc(op)
}
op <- splitlc(op)
op <- incon2fun(op, multiDim=FALSE, withLinCon=FALSE)
if(class(op$f)=="ratioFun"){
op <- f2fun(op)
}
if(is.null(op$inlc)){
cList <- NULL
}else{
nnoc1 <- nnoc(G=op$inlc$A, h=op$inlc$val)
cList <- list(nnoc1)
}
gc()
myf <- list()
myg <- list()
myh <- list()
for(i in seq_along(op$infun$f0)){
op$infun$val[[i]]<-op$infun$val[[i]]-0.001
}
for(i in seq_along(op$infun$f0)){
if(is.null(X) || op$infun$f0[[i]](X)>=0){
X <- getx(cccp( P = op$infun$Q[[i]],
q = op$infun$a[[i]],
A = op$eqlc$A,
b = op$eqlc$val,
cList = cList,
nlfList= myf,
nlgList= myg,
nlhList= myh,
x0 = X,
optctrl=optctrl))[,1]
if(length(X)==0){X <- rep(NA, length(op$id))}
if(!is.null(op$eqlc)){op$eqlc$val <- c(op$eqlc$A%*%X)}
}
myf[[i]] <- op$infun$f0[[i]]
myg[[i]] <- op$infun$g0[[i]]
myh[[i]] <- op$infun$h0[[i]]
gc()
if(op$infun$f0[[i]](X)>0){
cat("No solution exists.\n");
X <- setNames(X, op$id)
return(list(x=X, solver="cccp2", status="No solution exists."))
}
}
for(i in seq_along(op$infun$f0)){
op$infun$val[[i]] <- op$infun$val[[i]]+0.001
}
gc()
if(class(op$f)=="Fun"){
res <- cccp(f0=op$f$f0, g0=op$f$g0, h0=op$f$h0, x0=X, A=op$eqlc$A, b=op$eqlc$val, cList=cList, nlfList=op$infun$f0, nlgList=op$infun$g0, nlhList=op$infun$h0, optctrl=optctrl)
}else{
res <- cccp(P=op$f$Q, q=0.5*op$f$a, x0=X, A=op$eqlc$A, b=op$eqlc$val, cList=cList, nlfList=op$infun$f0, nlgList=op$infun$g0, nlhList=op$infun$h0, optctrl=optctrl)
}
if(length(getx(res))==0){
x <- rep(NA, length(op$id))
}else{
x <- c(getx(res))
}
x <- setNames(x, op$id)
res <- list(x=x, solver="cccp2", status=res$status)
res
}
|
context("surv_model_performance")
source("objects_for_tests.R")
test_that("Creating surv_model_performance", {
expect_is(mp_cph, "surv_model_performance_explainer")
expect_is(mp_cph, "BS")
expect_is(mp_cph_artificial, "surv_model_performance_explainer")
})
test_that("Wrong input",{
expect_error(model_performance(cph_model))
expect_error(model_performance(surve_cph_null_data))
})
|
GeomPointRast <- ggplot2::ggproto(
"GeomPointRast",
ggplot2::GeomPoint,
draw_panel = function(self, data, panel_params, coord, raster.dpi, dev, scale) {
grob <- ggproto_parent(GeomPoint, self)$draw_panel(data, panel_params, coord)
class(grob) <- c("rasteriser", class(grob))
grob$dpi <- raster.dpi
grob$dev <- dev
grob$scale <- scale
return(grob)
}
)
DrawGeomBoxplotJitter <- function(data, panel_params, coord, dev="cairo", ...,
outlier.jitter.width=NULL,
outlier.jitter.height=0,
outlier.colour = NULL,
outlier.fill = NULL,
outlier.shape = 19,
outlier.size = 1.5,
outlier.stroke = 0.5,
outlier.alpha = NULL,
raster=FALSE, raster.dpi=getOption("ggrastr.default.dpi", 300),
raster.width=NULL, raster.height=NULL,
scale = 1
) {
boxplot_grob <- ggplot2::GeomBoxplot$draw_group(data, panel_params, coord, ...)
point_grob <- grep("geom_point.*", names(boxplot_grob$children))
if (length(point_grob) == 0){
return(boxplot_grob)
}
ifnotnull <- function(x, y) if(is.null(x)) y else x
if (is.null(outlier.jitter.width)) {
outlier.jitter.width <- (data$xmax - data$xmin) / 2
}
x <- data$x[1]
y <- data$outliers[[1]]
if (outlier.jitter.width > 0 & length(y) > 1) {
x <- jitter(rep(x, length(y)), amount=outlier.jitter.width)
}
if (outlier.jitter.height > 0 & length(y) > 1) {
y <- jitter(y, amount=outlier.jitter.height)
}
outliers <- data.frame(
x = x, y = y,
colour = ifnotnull(outlier.colour, data$colour[1]),
fill = ifnotnull(outlier.fill, data$fill[1]),
shape = ifnotnull(outlier.shape, data$shape[1]),
size = ifnotnull(outlier.size, data$size[1]),
stroke = ifnotnull(outlier.stroke, data$stroke[1]),
fill = NA,
alpha = ifnotnull(outlier.alpha, data$alpha[1]),
stringsAsFactors = FALSE
)
boxplot_grob$children[[point_grob]] <- GeomPointRast$draw_panel(outliers, panel_params, coord, raster.dpi=raster.dpi, dev=dev, scale = scale)
return(boxplot_grob)
}
GeomBoxplotJitter <- ggplot2::ggproto("GeomBoxplotJitter",
ggplot2::GeomBoxplot,
draw_group = DrawGeomBoxplotJitter)
geom_boxplot_jitter <- function(mapping = NULL, data = NULL, dev = "cairo",
stat = "boxplot", position = "dodge",
na.rm = FALSE, show.legend = NA,
inherit.aes = TRUE, ...,
outlier.jitter.width=NULL,
outlier.jitter.height=0,
raster.dpi=getOption("ggrastr.default.dpi", 300),
scale = 1
) {
ggplot2::layer(
geom = GeomBoxplotJitter, mapping = mapping, data = data, stat = stat,
position = position, show.legend = show.legend, inherit.aes = inherit.aes,
params = list(na.rm = na.rm,
outlier.jitter.width=outlier.jitter.width,
outlier.jitter.height=outlier.jitter.height,
raster.dpi=raster.dpi, dev=dev, scale = scale, ...))
}
|
data_plot.parameters_simulate <- function(x,
data = NULL,
normalize_height = FALSE,
...) {
if (is.null(data)) {
data <- .retrieve_data(x)
}
n_sims <- attr(x, "n_sims")
dat <- parameters::simulate_model(model = data, n_sims = n_sims)
params <- insight::clean_parameters(data)
out <- bayestestR::estimate_density(dat)
if (isTRUE(normalize_height)) {
out$y <- datawizard::data_rescale(out$y, to = c(0, .9))
}
if (length(unique(params$Effects)) > 1) {
out$Effects <- NA
if (length(unique(params$Component)) > 1) {
zi_comp <- params$Component == "zero_inflated"
params$Parameter[zi_comp] <- paste0(params$Parameter[zi_comp], "_zi")
disp_comp <- params$Component == "dispersion"
params$Parameter[disp_comp] <- paste0(params$Parameter[disp_comp], "_disp")
}
for (i in names(dat)) {
if (i %in% params$Parameter && i %in% out$Parameter) {
out$Effects[out$Parameter == i] <- params$Effects[params$Parameter == i]
}
}
if (length(unique(params$Component)) > 1) {
out$Component <- NA
for (i in names(dat)) {
if (i %in% params$Parameter && i %in% out$Parameter) {
out$Component[out$Parameter == i] <- params$Component[params$Parameter == i]
}
}
}
}
if (!is.null(attributes(x)$object_class) && "mlm" %in% attributes(x)$object_class) {
out$Component <- NA
for (i in unique(params$Response)) {
out$Component[grepl(paste0(i, "$"), out$Parameter)] <- i
out$Parameter <- gsub(paste0(i, "$"), "", out$Parameter)
}
}
out
}
plot.see_parameters_simulate <- function(x,
data = NULL,
stack = TRUE,
show_intercept = FALSE,
n_columns = NULL,
normalize_height = FALSE,
size_line = .9,
posteriors_alpha = 0.7,
centrality = "median",
ci = 0.95,
...) {
is_mlm <- !is.null(attributes(x)$object_class) && "mlm" %in% attributes(x)$object_class
if (is.null(n_columns) && isTRUE(is_mlm)) n_columns <- 1
if (missing(centrality) && !is.null(attributes(x)$centrality)) {
centrality <- attributes(x)$centrality
}
if (!"data_plot" %in% class(x)) {
x <- data_plot(x, data = data, normalize_height = normalize_height)
}
plot.see_estimate_density(
x,
stack = stack,
show_intercept = show_intercept,
n_columns = n_columns,
size_line = size_line,
posteriors_alpha = posteriors_alpha,
centrality = centrality,
ci = ci,
...
)
}
|
pcoxsurvfit.pcoxtime <- function(fit, newdata, ...){
afit <- predictedHazard(fit)
chaz <- afit$chaz
surv.est <- exp(-chaz)
if (!missing(newdata)){
lp <- predict(fit, newdata = newdata, type = "lp")
surv.est <- t(sapply(surv.est, function(x) x^exp(lp)))
chaz <- -log(surv.est)
}
out <- list(n = afit$n
, events = sum(afit$n.event)
, time = afit$time
, n.risk = afit$n.risk
, n.event = afit$n.event
, n.censor = afit$n.censor
, surv = surv.est
, cumhaz = chaz
)
out$call <- match.call()
class(out) <- "pcoxsurvfit"
out
}
pcoxbasehaz.pcoxtime <- function(fit, centered = TRUE){
sfit <- pcoxsurvfit.pcoxtime(fit)
chaz <- sfit$cumhaz
surv.est <- exp(-chaz)
if (!centered) {
beta.hat <- drop(fit$coef)
X.mean <- fit$means
offset <- drop(X.mean %*% beta.hat)
chaz <- chaz * exp(-offset)
surv.est <- exp(-chaz)
}
out <- list(time = sfit$time, hazard = chaz, surv = surv.est)
out$call <- match.call()
class(out) <- c("pcoxbasehaz", "pcoxsurvfit")
out
}
predict.pcoxtime <- function(object, ..., newdata = NULL, type = c("lp", "risk", "expected", "terms", "survival"), terms = object$predictors, na.action = na.pass){
if (!missing(terms)){
if (any(is.na(match(terms, object$predictors))))
stop("a name given in the terms argument not found in the model")
}
type <- match.arg(type)
if (type == "survival") {
survival <- TRUE
type <- "expected"
} else {
survival <- FALSE
}
beta.hat <- drop(object$coef)
timevar <- object$timevarlabel
eventvar <- object$eventvarlabel
all_terms <- object$predictors
if (!is.null(newdata)) {
if(type == "expected"){
new_form <- object$terms
m <- model.frame(new_form, data = newdata
, xlev = object$xlevels, na.action = na.action
, drop.unused.levels = TRUE
)
newY <- model.extract(m, "response")
} else{
new_form <- delete.response(object$terms)
m <- model.frame(new_form, data = newdata
, xlev = object$xlevels, na.action = na.action
, drop.unused.levels = TRUE
)
}
newX <- model.matrix(new_form, m, contr = object$contrasts, xlev = object$xlevels)
xnames <- colnames(newX)
assign <- setNames(attr(newX, "assign"), xnames)[-1]
xnames <- names(assign)
newX <- newX[ , xnames, drop=FALSE]
} else {
df <- object$data
newY <- object$Y
events <- df[, eventvar]
times <- df[, timevar]
assign <- object$assign
xnames <- names(assign)
newX <- df[, xnames, drop = FALSE]
}
xmeans <- object$means[xnames]
newX.centered <- newX - rep(xmeans, each = NROW(newX))
lp <- unname(drop(newX.centered %*% beta.hat))
if (type == "terms"){
term_list <- list()
tvals <- unique(assign)
for (i in seq_along(tvals)){
w <- assign == tvals[i]
term_list[[i]] <- newX.centered[, w, drop = FALSE] %*% beta.hat[w]
}
terms_df <- do.call("cbind", term_list)
colnames(terms_df) <- all_terms
if(!missing(terms)){ terms_df <- terms_df[, terms, drop = FALSE]}
}
if (type == "expected"){
afit <- predictedHazard(object)
times <- afit$time
afit.n <- length(times)
newrisk <- drop(exp(newX.centered %*% beta.hat))
j1 <- approx(times, 1:afit.n, newY[,1], method = "constant", f = 0, yleft = 0, yright = afit.n)$y
chaz <- c(0, afit$chaz)[j1 + 1]
if (NCOL(newY)==2){
expected <- unname(chaz * newrisk)
} else {
j2 <- approx(times, 1:afit.n, newY[,2], method = "constant", f = 0, yleft = 0, yright = afit.n)$y
chaz2 <- c(0, afit$chaz)[j2 + 1]
expected <- unname((chaz2 - chaz) * newrisk)
}
if (survival){
survival <- exp(-expected)
type <- "survival"
}
}
out <- switch(type
, lp = lp
, risk = exp(lp)
, terms = terms_df
, expected = expected
, survival = survival
)
return(out)
}
predictedHazard <- function(fit){
oldY <- fit$Y
wt <- rep(1, NROW(oldY))
assign <- fit$assign
xnames <- names(assign)
oldX <- fit$data[, xnames, drop = FALSE]
beta.hat <- fit$coef
xmeans <- fit$means
oldX.centered <- oldX - rep(xmeans, each = NROW(oldX))
oldlp <- unname(drop(oldX.centered %*% beta.hat))
oldrisk <- exp(oldlp)
status <- oldY[, ncol(oldY)]
dtime <- oldY[, ncol(oldY) - 1]
death <- (status == 1)
time <- sort(unique(dtime))
nevent <- as.vector(rowsum(wt * death, dtime))
ncens <- as.vector(rowsum(wt * (!death), dtime))
wrisk <- wt * oldrisk
rcumsum <- function(x) rev(cumsum(rev(x)))
nrisk <- rcumsum(rowsum(wrisk, dtime))
irisk <- rcumsum(rowsum(wt, dtime))
if (NCOL(oldY) != 2){
delta <- min(diff(time))/2
etime <- c(sort(unique(oldY[, 1])), max(oldY[, 1]) + delta)
indx <- approx(etime, 1:length(etime), time, method = "constant", rule = 2, f = 1)$y
esum <- rcumsum(rowsum(wrisk, oldY[, 1]))
nrisk <- nrisk - c(esum, 0)[indx]
irisk <- irisk - c(rcumsum(rowsum(wt, oldY[, 1])), 0)[indx]
}
haz <- nevent/nrisk
result <- list(n = NROW(oldY), time = time, n.event = nevent
, n.risk = irisk, n.censor = ncens, hazard = haz, chaz = cumsum(haz)
)
return(result)
}
predictSurvProb.pcoxtime <- function(object, newdata, times, ...){
N <- NROW(newdata)
sfit <- pcoxsurvfit(object, newdata = newdata)
S <- t(sfit$surv)
Time <- sfit$time
if(N == 1) S <- matrix(S, nrow = 1)
p <- cbind(1, S)[, 1 + prodlim::sindex(Time, times),drop = FALSE]
p
}
predictRisk.pcoxtime <- function(object, newdata, times, ...){
p <- 1 - predictSurvProb.pcoxtime(object, newdata, times)
p
}
concordScore.pcoxtime <- function(fit, newdata = NULL, stats = FALSE, reverse = TRUE, ...){
if (is.null(newdata)) {
risk <- predict(fit, type = "risk")
y <- model.extract(model.frame(fit), "response")
} else {
risk <- predict(fit, newdata = newdata, type = "risk")
y <- model.extract(model.frame(fit$terms, data = newdata), "response")
}
conindex <- survival::concordance(y ~ risk, reverse = reverse, ...)
if (!stats){
conindex <- conindex$concordance
}
return(conindex)
}
extractoptimal.pcoxtimecv <- function(object, what=c("optimal", "cvm", "coefs"), ...) {
what <- match.arg(what)
if (what=="optimal") {
out <- object$dfs$min_metrics_df
} else if (what=="cvm") {
out <- object$dfs$cvm
} else {
out <- object$fit$beta
if (is.null(out)) warning("Run the model with refit=TRUE to extract cross-validation coefficients.")
}
return(out)
}
pvimp.pcoxtime <- function(object, newdata, nrep=50
, parallelize=FALSE, nclusters=1, estimate=c("mean", "quantile")
, probs=c(0.025, 0.5, 0.975), seed=NULL, ...) {
if (is.null(seed) || !is.numeric(seed)) {
seed <- 911
set.seed(seed)
}
estimate <- match.arg(estimate)
overall_c <- concordScore.pcoxtime(object, newdata=newdata, stats=FALSE, reverse=TRUE, ...)
xvars <- all.vars(formula(delete.response(terms(object))))
N <- NROW(newdata)
if (parallelize) {
nn <- min(parallel::detectCores(), nclusters)
if (nn < 2){
foreach::registerDoSEQ()
} else{
cl <- parallel::makeCluster(nn)
doParallel::registerDoParallel(cl)
on.exit(parallel::stopCluster(cl))
}
x <- NULL
vi <- foreach(x = xvars, .export="concordScore.pcoxtime") %dopar% {
permute_df <- newdata[rep(seq(N), nrep), ]
if (is.factor(permute_df[,x])) {
permute_var <- as.vector(replicate(nrep, sample(newdata[,x], N, replace = FALSE)))
permute_var <- factor(permute_var, levels = levels(permute_df[,x]))
} else {
permute_var <- as.vector(replicate(nrep, sample(newdata[,x], N, replace = FALSE)))
}
index <- rep(1:nrep, each = N)
permute_df[, x] <- permute_var
perm_c <- unlist(lapply(split(permute_df, index), function(d){
concordScore.pcoxtime(object, newdata = d, stats = FALSE, reverse=TRUE, ...)
}))
est <- (overall_c - perm_c)/overall_c
out <- switch(estimate
, mean={
out2 <- mean(est)
names(out2) <- x
out2
}
, quantile={
out2 <- cbind.data.frame(...xx=x, t(quantile(est, probs = probs, na.rm = TRUE)))
colnames(out2) <- c("terms", "lower", "estimate", "upper")
out2
}
)
out
}
} else {
vi <- sapply(xvars, function(x){
permute_df <- newdata[rep(seq(N), nrep), ]
if (is.factor(permute_df[,x])) {
permute_var <- as.vector(replicate(nrep, sample(newdata[,x], N, replace = FALSE)))
permute_var <- factor(permute_var, levels = levels(permute_df[,x]))
} else {
permute_var <- as.vector(replicate(nrep, sample(newdata[,x], N, replace = FALSE)))
}
index <- rep(1:nrep, each = N)
permute_df[, x] <- permute_var
perm_c <- unlist(lapply(split(permute_df, index), function(d){
concordScore.pcoxtime(object, newdata = d, stats = FALSE, reverse=TRUE, ...)
}))
est <- (overall_c - perm_c)/overall_c
out <- switch(estimate
, mean={
out2 <- mean(est)
out2
}
, quantile={
out2 <- cbind.data.frame(...xx=x, t(quantile(est, probs = probs, na.rm = TRUE)))
colnames(out2) <- c("terms", "lower", "estimate", "upper")
out2
}
)
out
}, simplify = FALSE)
}
out <- switch(estimate
, mean={
unlist(vi)
}
, quantile={
est <- do.call("rbind", vi)
rownames(est) <- NULL
est
}
)
return(out)
}
coefvimp.pcoxtime <- function(object, relative=TRUE, ...) {
out <- data.frame(Overall=coef(object))
out$sign <- sign(out$Overall)
out$Overall <- abs(out$Overall)
if (relative){
out$Overall <- out$Overall/sum(out$Overall, na.rm = TRUE)
}
out$terms <- rownames(out)
rownames(out) <- NULL
out <- out[, c("terms", "Overall", "sign")]
return(out)
}
varimp.pcoxtime <- function(object, newdata, type=c("coef", "perm", "model")
, relative=TRUE, nrep=50, parallelize=FALSE, nclusters=1
, estimate=c("mean", "quantile"), probs=c(0.025, 0.5, 0.975), seed=NULL, ...) {
type <- match.arg(type)
estimate <- match.arg(estimate)
if (type=="model") {
type <- "coef"
}
if (type=="coef") {
out <- coefvimp.pcoxtime(object, relative=relative)
} else if (type=="perm") {
out <- pvimp.pcoxtime(object=object, newdata=newdata, nrep=nrep
, parallelize=parallelize, nclusters=nclusters, estimate=estimate
, probs=probs
)
if (estimate=="mean") {
out <- data.frame(Overall=out)
out$sign <- sign(out$Overall)
out$Overall <- abs(out$Overall)
if (relative) {
out$Overall <- out$Overall/sum(out$Overall, na.rm = TRUE)
}
out$terms <- rownames(out)
rownames(out) <- NULL
out <- out[, c("terms", "Overall", "sign")]
}
}
if (type=="coef") estimate <- "mean"
attr(out, "estimate") <- estimate
class(out) <- c("varimp", class(out))
return(out)
}
|
testColoc <- function(im1, im2, hres = 0.1023810, vres = 0.2500000, B=999, alternative = "less", returnSample = TRUE, ...){
centers <- rbind(im1$moments[,c('m.x','m.y','m.z')], im2$moments[,c('m.x','m.y','m.z')])
centers <- t(t(centers) * c(rep(hres,2),vres))
n1 <- nrow(im1$moments)
n2 <- nrow(im2$moments)
w <- c(im1$moments[,'w'], im2$moments[,'w'])
dist <- as.matrix(dist(centers))
return(cnnTest(dist, n1, n2, w, B, alternative, returnSample, ...))
}
|
export_csv <- function(graph,
ndf_name = "nodes.csv",
edf_name = "edges.csv",
output_path = getwd(),
colnames_type = NULL) {
fcn_name <- get_calling_fcn()
if (graph_object_valid(graph) == FALSE) {
emit_error(
fcn_name = fcn_name,
reasons = "The graph object is not valid")
}
nodes_df <- get_node_df(graph)
edges_df <- get_edge_df(graph)
if (!is.null(colnames_type)) {
if (colnames_type == "neo4j") {
colnames(nodes_df)[1:3] <-
c("nodes:ID", ":LABEL", "label")
colnames(edges_df)[1:3] <-
c(":START_ID", ":END_ID", ":TYPE")
}
if (colnames_type == "graphframes") {
colnames(nodes_df)[1] <- "id"
colnames(edges_df)[1:2] <-
c("src", "dst")
}
}
utils::write.csv(
nodes_df,
file = paste0(output_path,
"/", ndf_name),
row.names = FALSE, quote = FALSE)
utils::write.csv(
edges_df,
file = paste0(output_path,
"/", edf_name),
row.names = FALSE, quote = FALSE)
}
|
class_entropy <- function(conf_mat) {
mle_prob <- function(x) {
prob <- x / sum(x)
sum(abs(prob * ifelse(prob != 0, log2(prob), 0)))
}
list(row_entropy = apply(conf_mat, 1, mle_prob),
col_entropy = apply(conf_mat, 2, mle_prob))
}
class_purity <- function(conf_mat) {
list(row_purity = apply(conf_mat, 1, max) / apply(conf_mat, 1, sum),
col_purity = apply(conf_mat, 2, max) / apply(conf_mat, 2, sum))
}
|
optimbase.histset <- function(this=NULL,iter=NULL,key=NULL,value=NULL){
if (!this$storehistory)
stop('optimbase.histset: History disabled ; turn on storehistory option.',
call.=FALSE)
if (iter<1)
stop('optimbase.histset: Negative iteration index are not allowed.',
call.=FALSE)
if (!any(key==c('historyxopt','historyfopt')))
stop(sprintf('optimbase.histset: Unknown key %s',key),
call.=FALSE)
if (key=='historyxopt') this$historyxopt[[iter]] <- value
if (key=='historyfopt') this$historyfopt[iter] <- value
return(this)
}
|
context("Test bandit4arm_2par_lapse")
library(hBayesDM)
test_that("Test bandit4arm_2par_lapse", {
skip_on_cran()
expect_output(bandit4arm_2par_lapse(
data = "example", niter = 10, nwarmup = 5, nchain = 1, ncore = 1))
})
|
model_parameters.epi.2by2 <- function(model, verbose = TRUE, ...) {
params <- insight::get_parameters(model)
colnames(params)[2] <- "Coefficient"
coef_names <- grepl("^([^NNT]*)(\\.strata\\.wald)", names(model$massoc.detail), perl = TRUE)
cf <- model$massoc.detail[coef_names]
names(cf) <- gsub(".strata.wald", "", names(cf), fixed = TRUE)
cis <- do.call(rbind, cf)
cis$Parameter <- rownames(cis)
cis$est <- NULL
colnames(cis) <- c("CI_low", "CI_high", "Parameter")
params <- merge(params, cis, sort = FALSE)
fractions <- params$Parameter %in% c("AFRisk", "PAFRisk")
params[fractions, c("Coefficient", "CI_low", "CI_high")] <- 100 * params[fractions, c("Coefficient", "CI_low", "CI_high")]
pretty_names <- params$Parameter
pretty_names[pretty_names == "PR"] <- "Prevalence Ratio"
pretty_names[pretty_names == "OR"] <- "Odds Ratio"
pretty_names[pretty_names == "ARisk"] <- "Attributable Risk"
pretty_names[pretty_names == "PARisk"] <- "Attributable Risk in Population"
pretty_names[pretty_names == "AFRisk"] <- "Attributable Fraction in Exposed (%)"
pretty_names[pretty_names == "PAFRisk"] <- "Attributable Fraction in Population (%)"
stats <- model$massoc.detail$chi2.strata.uncor
attr(params, "footer_text") <- paste0("Test that Odds Ratio = 1: Chi2(", stats[["df"]], ") = ", insight::format_value(stats[["test.statistic"]]), ", ", insight::format_p(stats[["p.value.2s"]]))
attr(params, "pretty_names") <- stats::setNames(pretty_names, params$Parameter)
attr(params, "no_caption") <- TRUE
class(params) <- c("parameters_model", "see_parameters_model", class(params))
params
}
|
CI.RMSEA <-
function(rmsea,df,N,clevel=.95){
if(length(rmsea)!=1|rmsea<0){stop('rmsea has to be correctly specified.')}
if(length(df)!=1|df<=0){stop('df has to be correctly specified.')}
if(length(N)!=1|N<=0){stop('N has to be correctly specified.')}
if(length(clevel)!=1|clevel<=0|clevel>=1){stop('clevel has to be correctly specified.')}
tol=.0000001;T=rmsea^2*df*(N-1)+df;C=qchisq(1-(1-clevel)/2,df)
if((T<C|rmsea==0)&N>1){;start=rmsea;O_U_P=(1-clevel)/2;P_LU=1
A=c(.01,.001,.0001,.00001,.000001,.0000001)
for(i in c(1,3,5)){;while(P_LU>O_U_P){
P_LU=pchisq(T,df,start^2*df*(N-1));if(P_LU>O_U_P){start=start+A[i]}}
while(P_LU<O_U_P){;P_LU=pchisq(T,df,start^2*df*(N-1))
if(P_LU<O_U_P){start=start-A[i+1]};if(start<0){start=0}}}
k=0;while(abs(P_LU-O_U_P)>tol&k<20){;P_LU=pchisq(T,df,start^2*df*(N-1))
if(P_LU>O_U_P){start=start+.00000001};if(P_LU<O_U_P){start=start-.00000001}
k=k+1;if(start<0){start=0}};if(k==20){;start1=start;start2=start+.00000001
s1=pchisq(T,df,start1^2*df*(N-1));s2=pchisq(T,df,start2^2*df*(N-1))
start=c(start1,start2)[which((abs(c(s1,s2)-O_U_P))==min(abs(c(s1,s2)-O_U_P)))]}
L.rmsea=0;U.rmsea=start};if(T>C&N>1){;O_U_P=(1-clevel)/2;P_LU=1;start=rmsea
A=c(.01,.001,.0001,.00001,.000001,.0000001)
for(i in c(1,3,5)){;while(P_LU>O_U_P){
P_LU=pchisq(T,df,start^2*df*(N-1));if(P_LU>O_U_P){start=start+A[i]}}
while(P_LU<O_U_P){;P_LU=pchisq(T,df,start^2*df*(N-1))
if(P_LU<O_U_P){start=start-A[i+1]};if(start<0){start=0}}}
k=0;while(abs(P_LU-O_U_P)>tol&k<20){;P_LU=pchisq(T,df,start^2*df*(N-1))
if(P_LU>O_U_P){start=start+.00000001};if(P_LU<O_U_P){start=start-.00000001}
k=k+1;if(start<0){start=0}};if(k==20){;start1=start;start2=start+.00000001
s1=pchisq(T,df,start1^2*df*(N-1));s2=pchisq(T,df,start2^2*df*(N-1))
start=c(start1,start2)[which((abs(c(s1,s2)-O_U_P))==min(abs(c(s1,s2)-O_U_P)))]}
U.rmsea=start;start=0;O_L_P=1-(1-clevel)/2;P_LL=1
A=c(.01,.001,.0001,.00001,.000001,.0000001)
for(i in c(1,3,5)){;while(P_LL>O_L_P){
P_LL=pchisq(T,df,start^2*df*(N-1));if(P_LL>O_L_P){start=start+A[i]}}
while(P_LL<O_L_P){;P_LL=pchisq(T,df,start^2*df*(N-1))
if(P_LL<O_L_P){start=start-A[i+1]};if(start<0){start=0}}}
k=0;while(abs(P_LL-O_L_P)>tol&k<20){;P_LL=pchisq(T,df,start^2*df*(N-1))
if(P_LL>O_L_P){start=start+.00000001};if(P_LL<O_L_P){start=start-.00000001}
k=k+1;if(start<0){start=0}};if(k==20){;start1=start;start2=start+.00000001
s1=pchisq(T,df,start1^2*df*(N-1));s2=pchisq(T,df,start2^2*df*(N-1))
start=c(start1,start2)[which((abs(c(s1,s2)-O_U_P))==min(abs(c(s1,s2)-O_U_P)))]}
L.rmsea=start};if(N==1){L.rmsea=0;U.rmsea=Inf}
list(Lower.CI=L.rmsea,RMSEA=rmsea,Upper.CI=U.rmsea)}
|
new_TRI0 <- function(vertex, object, index, crs = NA_character_, meta = NULL) {
meta1 <- tibble::tibble(proj = crs, ctime = Sys.time())
if (!is.null(meta)) {
meta <- rbind(meta1, meta)
}
object[["topology_"]] <- index
structure(list(object = object, vertex = vertex,
meta = meta), class = c("TRI0", "sc"))
}
TRI0 <- function(x, ...) {
UseMethod("TRI0")
}
TRI0.default <- function(x, ...) {
TRI0(PATH0(x), ...)
}
TRI0.mesh3d <- function(x, ...) {
index <- x[["it"]]
if (is.null(index)) {
index <- .quad2tri(x[["ib"]])
}
index <- t(index)
colnames(index) <- c(".vx0", ".vx1", ".vx2")
index <- tibble::as_tibble(index)
object <- tibble::tibble(object_ = 1)
v <- t(x[["vb"]])
colnames(v) <- c("x_", "y_", "z_", "h_")
vertex <- tibble::as_tibble(v)
crs <- NA_character_
if (!is.null(x[["crs"]]) && !is.na(x[["crs"]])) {
crs <- x[["crs"]]
}
new_TRI0(vertex, object, list(index), crs)
}
TRI0.TRI0 <- function(x, ...) {
x
}
TRI0.sfc_TIN <- function(x, ...) {
stop("TRI0 not implemented for TIN")
}
TRI0.TRI <- function(x, ...) {
o <- sc_object(x)
o$object_ <- NULL
topol <- x$triangle
v <- sc_vertex(x)
idx <- split(tibble::tibble(.vx0 = match(topol$.vx0, v$vertex_),
.vx1 = match(topol$.vx1, v$vertex_),
.vx2 = match(topol$.vx2, v$vertex_)),
topol$object_)[unique(topol$object_)]
v$vertex_ <- NULL
crs <- crsmeta::crs_proj(x)
new_TRI0(v, o, idx, crs, meta = x$meta)
}
TRI0.PATH0 <- function(x, ...) {
v <- sc_vertex(x)
v$vertex_ <- 1:nrow(v)
obj <- sc_object(x)
count <- 0
trilist <- list()
for (i in seq_len(nrow(obj))) {
topol <- obj$path_[[i]]
lsubs <- split(topol, topol$subobject)
for (j in seq_along(lsubs)) {
vidx <- lsubs[[j]]
verts <- inner_join(vidx[c("vertex_", "path_")], v[c("x_", "y_", "vertex_")], "vertex_")
holes <- which(c(0, abs(diff(as.integer(as.factor(verts$path_))))) > 0)
if (length(holes) < 1) holes <- 0
count <- count + 1
trindex <- decido::earcut(cbind(verts[["x_"]], verts[["y_"]]), holes)
trimat <- matrix(trindex, ncol = 3L, byrow = TRUE)
trilist[[count]] <- tibble::tibble(.vx0 = verts$vertex_[trimat[,1L]],
.vx1 = verts$vertex_[trimat[,2L]],
.vx2 = verts$vertex_[trimat[,3L]],
object_ = i,
path_ = lsubs[[j]]$path_[1L])
}
}
obj$path_ <- NULL
topology_ <- dplyr::bind_rows(trilist)
index <- split(topology_[c(".vx0", ".vx1",".vx2", "path_")], topology_$object_)
crs <- crsmeta::crs_proj(x)
new_TRI0(sc_vertex(x), obj, index, crs, meta = x$meta)
}
TRI0.PATH <- function(x, ...) {
vertex <- x$vertex
if (nrow(vertex) < 3) stop("need at least 3 coordinates")
if (anyNA(vertex$x_)) stop("missing values in x_")
if (anyNA(vertex$y_)) stop("missing values in y_")
TRI0(PATH0(x), ...)
}
TRI0.sf <- function(x, ...) {
sfcol <- attr(x, "sf_column")
out <- TRI0(x[[sfcol]])
x[[sfcol]] <- NULL
nm <- names(x)
for (i in seq_along(x)) {
if (nm[i] %in% c("topology_", "object_")) next;
out$object[[nm[i]]] <- x[[i]]
}
out
}
TRI0.sfc_GEOMETRYCOLLECTION <- function(x, ...) {
list_sfc <- unclass(x)
lens <- lengths(list_sfc)
corners <- rapply(list_sfc, function(x) dim(x)[1L], classes = "matrix", how = "unlist")
if (!all(corners == 4L)) stop("cannot 'TRI0' a GEOMETRYCOLLECTION not composed of triangles (POLYGON with 4 coordinates)")
coords <- do.call(rbind, lapply(unlist(list_sfc, recursive = FALSE), "[[", 1L))
first <- seq(1, nrow(coords), by = 4L)
fourth <- first + 3
if (!max(first) == (nrow(coords)-3) ||
!all(coords[first,1] == coords[fourth, 1]) ||
!all(coords[first,2] == coords[fourth, 2])) {
stop("GEOMETRYCOLLECTION appears to not be composed of POLYGON triangles")
}
if (ncol(coords) == 2L) {
coords <- cbind(coords, 0)
}
coords <- coords[-fourth, , drop = FALSE]
colnames(coords) <- c("x_", "y_", "z_")
topol <- matrix(1:(dim(coords)[1L]), byrow = TRUE, ncol = 3L)
colnames(topol) <- c(".vx0", ".vx1", ".vx2")
topol <- tibble::as_tibble(topol)
topol <- split(topol, rep(seq_along(lens), lens))
new_TRI0(tibble::as_tibble(coords), tibble::tibble(object_ = seq_along(lens)),
topol, crsmeta::crs_proj(x))
}
|
library(googleway)
api_key <- 'your_api_key'
res <- google_places(search_string = "Restaurants in Melbourne, Australia", key = api_key)
df_places <- google_places(search_string = "cafe", location = c(-37.81827, 144.9671), key = key)
df_places$results$name
res_next <- google_places(search_string = "Restaurants in Melbourne, Australia", page_token = res$next_page_token, key = api_key)
google_places(location = c(-37.817839,144.9673254),place_type = "bicycle_store", radius = 20000, key = api_key)
google_places(search_string = "Bicycle shop, Melbourne, Australia", open_now = TRUE, key = api_key)
|
GetBootstrapSD <- function(diseaseData,
controlData,
userFormula,
outform,
fixSens,
Nbootstrap = 100,
verbose = TRUE) {
allrec_bt <- matrix(NA, Nbootstrap, length(outform$allvar)+2)
if(verbose) {
message("Estimating standard error using bootstrap...")
}
for (nb in 1:Nbootstrap) {
oneindx1 <- sample(1:nrow(controlData), nrow(controlData), replace = TRUE)
oneindx2 <- sample(1:nrow(diseaseData), nrow(diseaseData), replace = TRUE)
controlData_bt <- controlData[oneindx1, ]
diseaseData_bt <- diseaseData[oneindx2, ]
if (length(outform[[2]]) == 1) {
expr2 <- paste0("controlData_bt$", outform[[2]])
expr3 <- paste0("diseaseData_bt$", outform[[2]])
} else if (length(outform[[2]]) > 1) {
expr2 <- paste0("controlData_bt[, ", outform[2], "]")
expr3 <- paste0("diseaseData_bt[, ", outform[2], "]")
}
Z_C_bt <- as.matrix(eval(parse(text = expr2)))
Z_D_bt <- as.matrix(eval(parse(text = expr3)))
M0_bt <- eval(parse(text = paste("controlData_bt$",outform[[1]])))
M1_bt <- eval(parse(text = paste("diseaseData_bt$",outform[[1]])))
rqfit <- NULL
expr1 <- paste0("rqfit <- rq(", userFormula, ", tau = ", 1-fixSens, ", data = diseaseData_bt)")
eval(parse(text = expr1))
est_b_bt <- as.numeric(rqfit$coefficients)
ctrl_threshold_bt <- cbind(1, Z_C_bt) %*% est_b_bt
case_threshold_bt <- cbind(1, Z_D_bt) %*% est_b_bt
onephi <- sum(M0_bt <= ctrl_threshold_bt)/length(M0_bt)
allrec_bt[nb, 1:(length(outform$allvar)+1)] <- est_b_bt
allrec_bt[nb, length(outform$allvar)+2] <- onephi
}
return(apply(allrec_bt, 2, sd))
}
|
data(Traffic, package = "MASS")
head(Traffic)
data(Traffic, package = "fastR2")
head(Traffic)
|
library(bayesplot)
context("Shared: misc. functions")
test_that("suggested_package throws correct errors", {
expect_error(suggested_package("NOPACKAGE"),
"Please install the NOPACKAGE package")
expect_error(suggested_package(c("testthat", "gridExtra")), "length")
expect_silent(suggested_package("testthat"))
expect_silent(suggested_package("testthat", min_version = "0.0.1"))
expect_error(suggested_package("testthat", min_version = "100000.0.0"))
})
test_that("check_ignored_arguments throws correct warnings", {
expect_warning(check_ignored_arguments(a = 1, b = "2"),
"The following arguments were unrecognized and ignored: a, b")
expect_warning(check_ignored_arguments(a = 1, b = "2", ok_args = c("a", "c")),
"The following arguments were unrecognized and ignored: b")
expect_silent(check_ignored_arguments(a = 1, b = "2", ok_args = c("a", "b", "c")))
})
all_pars <- c("param_1", "param_2",
"param[1]", "param[2]",
"param[1,3,5]", "param[2,4,5]",
"alpha", "beta")
test_that("select_parameters throws errors if 'explicit' not found", {
expect_error(select_parameters(explicit = c("alpha", "ALPHA"),
complete_pars = all_pars),
"don't match parameter names: ALPHA")
expect_error(select_parameters(c("BETA", "ALPHA"), complete = all_pars),
"don't match parameter names: BETA, ALPHA")
})
test_that("select_parameters throws errors if no regex matches", {
expect_error(select_parameters(explicit = c("alpha", "beta"),
patterns = "tomato|apple",
complete_pars = all_pars),
"No matches for 'regex_pars'")
})
test_that("select_parameters works with regex", {
expect_identical(select_parameters(patterns = "param", complete = all_pars),
all_pars[-c(7:8)])
expect_identical(select_parameters(patterns = c("param", "tomato"), complete_pars = all_pars),
all_pars[-c(7:8)])
expect_identical(select_parameters(patterns = c("param\\[", "tomato"), complete_pars = all_pars),
all_pars[3:6])
expect_identical(select_parameters(patterns = c("param\\_"), complete_pars = all_pars),
all_pars[1:2])
})
test_that("select_parameters works without regex", {
expect_identical(select_parameters(explicit = "alpha", complete_pars = all_pars),
"alpha")
expect_identical(select_parameters(c("alpha", "param[1,3,5]"), complete_pars = all_pars),
c("alpha", "param[1,3,5]"))
})
test_that("select_parameters works with both explicit and regex", {
expect_identical(select_parameters(explicit = "alpha",
patterns = "param",
complete_pars = all_pars),
c("alpha", all_pars[-c(7:8)]))
expect_identical(select_parameters(explicit = "alpha",
patterns = "alpha",
complete_pars = all_pars),
"alpha")
expect_identical(select_parameters(explicit = c("alpha", "beta"),
patterns = "param\\[|param\\_",
complete_pars = all_pars),
c(all_pars[7:8], all_pars[-c(7:8)]))
})
|
dl_trips_data_trondheim <- function(year, month, filetype = "CSV") {
filetype <- tolower(filetype)
base_url <- "http://data.urbansharing.com/trondheimbysykkel.no/trips/v1"
dl_url <- glue::glue("{base_url}/{year}/{sprintf('%0.2d', month)}.{filetype}")
if (httr::http_error(dl_url)) {
stop("The download URL is invalid.")
}
output_file <- glue::glue("trips_trondheim_{year}_{sprintf('%0.2d', month)}.{filetype}")
download.file(url = dl_url, destfile = output_file)
}
|
library(testthat)
library(imputeMulti)
context("int- impute multinomial")
test_that("missing value imputation works", {
enum_comp <- enum_w_miss[complete.cases(enum_w_miss),]
enum_miss <- enum_w_miss[!complete.cases(enum_w_miss),]
dat_comp <- dat[complete.cases(dat),]
dat_miss <- dat[!complete.cases(dat),]
iter6 <- multinomial_em(x_y= x_y, z_Os_y= z_Os_y, enum_comp= enum_comp,
n_obs= nrow(dat), conj_prior= "none",
verbose= FALSE, max_iter= 6)
dat_miss2 <- impute_multinomial_all(dat_miss, iter6@mle_x_y, p=ncol(dat))
imputed_data <- rbind(dat_comp, dat_miss2)
expect_equal(sum(!complete.cases(imputed_data)), 0)
expect_equal(sum(complete.cases(dat_miss2)), nrow(dat_miss2))
expect_equal(
lapply(dat_miss2, levels), lapply(dat, levels)
)
})
|
plot.see_check_collinearity <- function(x,
data = NULL,
colors = c("
...) {
if (is.null(data)) {
dat <- .compact_list(.retrieve_data(x))
} else {
dat <- data
}
if (is.null(dat)) {
return(NULL)
}
dat$group <- "low"
dat$group[dat$VIF >= 5 & dat$VIF < 10] <- "moderate"
dat$group[dat$VIF >= 10] <- "high"
if (ncol(dat) == 5) {
colnames(dat) <- c("x", "y", "se", "facet", "group")
dat[, c("x", "y", "facet", "group")]
} else {
colnames(dat) <- c("x", "y", "se", "group")
dat[, c("x", "y", "group")]
}
if (length(unique(dat$facet)) == 1) {
dat <- dat[, -which(colnames(dat) == "facet")]
}
.plot_diag_vif(dat, colors = colors)
}
|
source(file.path("aammrtf", "mock.R"))
source(file.path("_helper", "init.R"))
source(file.path("_helper", "pkgs.R"))
old.state <- tracingState(TRUE)
if (is(unitizer:::trace_test_fun, "functionWithTrace"))
untrace("trace_test_fun", where = asNamespace("unitizer"))
unitizer:::trace_at_end("trace_test_fun", quote(if (!inherits(.res,
"try-error")) cat(sprintf("x: %d\n", .res$value))), print = FALSE,
where = asNamespace("unitizer"))
coi(unitizer:::trace_test_fun())
tracingState(FALSE)
identical(capture.output(unitizer:::trace_test_fun()), character())
tracingState(TRUE)
err <- try(unitizer:::trace_test_fun(stop("hello")), silent = TRUE)
cond <- attr(err, "condition")
conditionMessage(cond)
conditionCall(cond)
f <- function(x, y, z = 5) {
if (missing(x)) {
return(TRUE)
}
else if (z > 5) {
stop("OMG, z > 5")
}
else if (identical(substitute(y), "hey")) {
"substitute!"
}
else FALSE
}
unitizer:::trace_at_end("f", quote(cat("hello\n")), FALSE, environment())
res <- f()
res
res2 <- f(1)
res2
err <- try(f(1, z = 6), silent = TRUE)
is(err, "try-error")
attr(err, "condition")
res3 <- f(1, y = "hey")
res3
try(detach("package:unitizerdummypkg1", unload = TRUE), silent = TRUE)
while ("unitizer.dummy.list" %in% search()) try(detach("unitizer.dummy.list"))
unitizer.dummy.list <- list(z = 23, x = 1, y = "hello")
my.env <- new.env()
state.set <- c(search.path = 2L)
untz.glob <- unitizer:::unitizerGlobal$new(par.env = my.env,
enable.which = state.set, set.global = TRUE)
untz.glob$shimFuns()
sp <- search()
curr2 <- sp[[2L]]
identical(environmentName(parent.env(my.env)), curr2)
library("unitizerdummypkg1", lib.loc = TMP.LIB)
identical(environmentName(parent.env(my.env)), "package:unitizerdummypkg1")
attach(unitizer.dummy.list)
identical(environmentName(parent.env(my.env)), "unitizer.dummy.list")
detach("unitizer.dummy.list")
identical(environmentName(parent.env(my.env)), "package:unitizerdummypkg1")
detach("package:unitizerdummypkg1", unload = TRUE)
identical(environmentName(parent.env(my.env)), curr2)
untz.glob$checkShims()
untz.glob$state()
keep.more <- c(getOption("unitizer.search.path.keep.base"))
unitizer:::search_path_trim(keep.more, global = untz.glob)
untz.glob$state()
identical(environmentName(parent.env(my.env)), search()[[2L]])
untz.glob$resetFull()
identical(environmentName(parent.env(my.env)), curr2)
untz.glob$unshimFuns()
!any(vapply(list(library, detach, attach), inherits, logical(1L),
"functionWithTrace"))
untz.glob$release()
untz.glob <- unitizer:::unitizerGlobal$new(par.env = my.env,
enable.which = state.set, set.global = TRUE)
tracingState(FALSE)
untz.glob$shimFuns()
parent.env(my.env)
tracingState(TRUE)
untz.glob$release()
untz.glob <- unitizer:::unitizerGlobal$new(par.env = my.env,
set.global = TRUE)
trace("library", quote(cat("I am traced\n")), where = .BaseNamespaceEnv)
lib.trace <- library
untz.glob$shimFuns()
parent.env(my.env)
inherits(attach, "functionWithTrace")
inherits(detach, "functionWithTrace")
inherits(library, "functionWithTrace")
identical(lib.trace, library)
untrace("library", where = .BaseNamespaceEnv)
untz.glob$release()
untz.glob <- unitizer:::unitizerGlobal$new(par.env = my.env,
set.global = TRUE)
untz.glob$shimFuns()
trace("attach", quote(cat("I am traced\n")), where = .BaseNamespaceEnv)
attach.trace <- attach
untz.glob$checkShims()
parent.env(my.env)
inherits(detach, "functionWithTrace")
inherits(library, "functionWithTrace")
inherits(attach, "functionWithTrace")
identical(attach.trace, attach)
untrace("attach", where = .BaseNamespaceEnv)
untz.glob$release()
untz.glob <- unitizer:::unitizerGlobal$new(par.env = my.env,
set.global = TRUE)
untz.glob$shimFuns()
tracingState(FALSE)
untz.glob$checkShims()
parent.env(my.env)
tracingState(TRUE)
inherits(detach, "functionWithTrace")
inherits(library, "functionWithTrace")
inherits(attach, "functionWithTrace")
untz.glob$shimFuns("baljevzxhjLsdc")
try(untz.glob$shimFun("sum"))
mock(unitizer:::trace_at_end, quote(stop("trace_at_end fail")))
any(
grepl(
"trace_at_end fail",
capture.output(
trace.fail <- untz.glob$shimFun("library"), type = "message"
),
fixed = TRUE
)
)
unmock(unitizer:::trace_at_end)
trace.fail
mock(unitizer:::trace_at_end, quote(message("random message")))
untz.glob$shimFun("library")
unmock(unitizer:::trace_at_end)
mock(unitizer:::trace_at_end, quote(TRUE))
dont.trace <- untz.glob$shimFun("library")
unmock(unitizer:::trace_at_end)
dont.trace
untz.glob$release()
untz.glob <- unitizer:::unitizerGlobal$new(par.env = my.env, set.global = TRUE)
untz.glob$shimFuns()
mock(
unitizer:::untrace_utz,
quote({
message("untrace dummy")
base::untrace(what = what, signature = signature, where = where)
})
)
untz.glob$unshimFuns()
unmock(unitizer:::untrace_utz)
untz.glob$release()
try(detach("package:unitizerdummypkg1", unload = TRUE), silent = TRUE)
while ("unitizer.dummy.list" %in% search()) try(detach("unitizer.dummy.list"))
fun <- function() {
if (TRUE)
return(1)
else {
{
2 + 2
identity(c(1, 2, return(3), {
list(1, 2, 5)
return(return(4))
}))
return(5)
}
return(6)
}
if (TRUE)
return(7)
else return(8)
return(9)
return(10)
}
ret.loc <- unitizer:::find_returns(fun)
ret.loc
all(vapply(unitizer:::get_returns(fun, ret.loc), function(x) x[[1L]] ==
quote(return), logical(1L)))
|
layer_spatial <- function(data, mapping, ...) {
UseMethod("layer_spatial")
}
annotation_spatial <- function(data, mapping, ...) {
UseMethod("annotation_spatial")
}
layer_spatial.default <- function(data, mapping = aes(), inherit.aes = FALSE, sf_params = list(), ...) {
ggplot2::geom_sf(
mapping = mapping,
data = do.call(sf::st_as_sf, c(list(data), sf_params)),
inherit.aes = inherit.aes,
...
)
}
annotation_spatial.default <- function(data, mapping = aes(), inherit.aes = FALSE, sf_params = list(), ...) {
ggplot2::geom_sf(
mapping = mapping,
data = do.call(sf::st_as_sf, c(list(data), sf_params)),
inherit.aes = inherit.aes,
na.rm = TRUE,
stat = StatSfAnnotation,
...
)
}
shadow_spatial <- function(data, ...) {
UseMethod("shadow_spatial")
}
shadow_spatial.default <- function(data, ...) {
ggplot2::stat_sf(
mapping = aes(),
data = sf::st_as_sf(data),
inherit.aes = FALSE,
na.rm = FALSE,
geom = GeomBlankSf
)
}
StatSfAnnotation <- ggplot2::ggproto(
"StatSfAnnotation",
ggplot2::StatSf,
compute_group = function(data, scales) {
data$xmin <- NA_real_
data$xmax <- NA_real_
data$ymin <- NA_real_
data$ymax <- NA_real_
data
}
)
GeomBlankSf <- ggplot2::ggproto(
"GeomBlankSf",
ggplot2::GeomBlank,
extra_params = c(ggplot2::GeomBlank$extra_params, "legend")
)
|
make_progression_handler <- function(name, reporter = list(), handler = NULL, enable = getOption("progressr.enable", interactive()), enable_after = getOption("progressr.enable_after", 0.0), times = getOption("progressr.times", +Inf), interval = getOption("progressr.interval", 0.0), intrusiveness = 1.0, clear = getOption("progressr.clear", TRUE), target = "terminal", ...) {
enable <- as.logical(enable)
stop_if_not(is.logical(enable), length(enable) == 1L, !is.na(enable))
if (!enable) times <- 0
name <- as.character(name)
stop_if_not(length(name) == 1L, !is.na(name), nzchar(name))
stop_if_not(is.list(reporter))
enable_after <- as.numeric(enable_after)
stop_if_not(is.numeric(enable_after), length(enable_after),
!is.na(enable_after), enable_after >= 0)
times <- as.numeric(times)
stop_if_not(length(times) == 1L, is.numeric(times), !is.na(times),
times >= 0)
interval <- as.numeric(interval)
stop_if_not(length(interval) == 1L, is.numeric(interval),
!is.na(interval), interval >= 0)
clear <- as.logical(clear)
stop_if_not(is.logical(clear), length(clear) == 1L, !is.na(clear))
stop_if_not(is.character(target))
if (times == 0 || is.infinite(interval) || is.infinite(intrusiveness)) {
handler <- function(p) NULL
}
for (key in setdiff(c("reset", "initiate", "update", "finish", "hide", "unhide", "interrupt"), names(reporter))) {
reporter[[key]] <- structure(function(...) NULL, class = "null_function")
}
active <- FALSE
max_steps <- NULL
step <- NULL
message <- NULL
auto_finish <- TRUE
timestamps <- NULL
milestones <- NULL
prev_milestone <- NULL
finished <- FALSE
enabled <- FALSE
owner <- NULL
done <- list()
.validate_internal_state <- function(label = "<no-label>") {
error <- function(...) {
msg <- sprintf(...)
stop(sprintf(".validate_internal_state(%s): %s", sQuote(label), msg))
}
if (!is.null(timestamps)) {
if (length(timestamps) == 0L) {
error(paste("length(timestamps) == 0L but not is.null(timestamps):",
sQuote(deparse(timestamps))))
}
}
}
reporter_args <- function(progression) {
.validate_internal_state("reporter_args() ... begin")
if (!enabled && !is.null(timestamps)) {
dt <- difftime(Sys.time(), timestamps[1L], units = "secs")
enabled <<- (dt >= enable_after)
}
config <- list(
max_steps = max_steps,
times = times,
interval = interval,
enable_after = enable_after,
auto_finish = auto_finish,
clear = clear,
target = target
)
state <- list(
step = step,
message = message,
timestamps = timestamps,
delta = step - prev_milestone,
enabled = enabled
)
if (length(state$delta) == 0L) state$delta <- 0L
.validate_internal_state("reporter_args() ... end")
c(config, state, list(
config = config,
state = state,
progression = progression
))
}
reset_internal_state <- function() {
active <<- FALSE
max_steps <<- NULL
step <<- NULL
message <<- NULL
auto_finish <<- TRUE
timestamps <<- NULL
milestones <<- NULL
prev_milestone <<- NULL
finished <<- FALSE
enabled <<- FALSE
owner <<- NULL
done <<- list()
}
reset_reporter <- function(p) {
args <- reporter_args(progression = p)
debug <- getOption("progressr.debug", FALSE)
if (debug) {
mprintf("reset_reporter() ...")
mstr(args)
}
do.call(reporter$reset, args = args)
.validate_internal_state("reset_reporter() ... done")
if (debug) mprintf("reset_reporter() ... done")
}
initiate_reporter <- function(p) {
args <- reporter_args(progression = p)
debug <- getOption("progressr.debug", FALSE)
if (debug) {
mprintf("initiate_reporter() ...")
mstr(args)
}
stop_if_not(!isTRUE(active))
stop_if_not(is.null(prev_milestone), length(milestones) > 0L)
do.call(reporter$initiate, args = args)
active <<- TRUE
finished <<- FALSE
.validate_internal_state("initiate_reporter() ... done")
if (debug) mprintf("initiate_reporter() ... done")
}
update_reporter <- function(p) {
args <- reporter_args(progression = p)
debug <- getOption("progressr.debug", FALSE)
if (debug) {
mprintf("update_reporter() ...")
mstr(args)
}
stop_if_not(isTRUE(active))
stop_if_not(!is.null(step), length(milestones) > 0L)
do.call(reporter$update, args = args)
.validate_internal_state("update_reporter() ... done")
if (debug) mprintf("update_reporter() ... done")
}
hide_reporter <- function(p) {
args <- reporter_args(progression = p)
debug <- getOption("progressr.debug", FALSE)
if (debug) {
mprintf("hide_reporter() ...")
mstr(args)
}
if (is.null(reporter$hide)) {
if (debug) mprintf("hide_reporter() ... skipping; not supported")
return()
}
do.call(reporter$hide, args = args)
.validate_internal_state("hide_reporter() ... done")
if (debug) mprintf("hide_reporter() ... done")
}
unhide_reporter <- function(p) {
args <- reporter_args(progression = p)
debug <- getOption("progressr.debug", FALSE)
if (debug) {
mprintf("unhide_reporter() ...")
mstr(args)
}
if (is.null(reporter$unhide)) {
if (debug) mprintf("unhide_reporter() ... skipping; not supported")
return()
}
do.call(reporter$unhide, args = args)
.validate_internal_state("unhide_reporter() ... done")
if (debug) mprintf("unhide_reporter() ... done")
}
interrupt_reporter <- function(p) {
args <- reporter_args(progression = p)
debug <- getOption("progressr.debug", FALSE)
if (debug) {
mprintf("interrupt_reporter() ...")
mstr(args)
}
if (is.null(reporter$interrupt)) {
if (debug) mprintf("interrupt_reporter() ... skipping; not supported")
return()
}
do.call(reporter$interrupt, args = args)
.validate_internal_state("interrupt_reporter() ... done")
if (debug) mprintf("interrupt_reporter() ... done")
}
finish_reporter <- function(p) {
args <- reporter_args(progression = p)
debug <- getOption("progressr.debug", FALSE)
if (debug) {
mprintf("finish_reporter() ...")
mstr(args)
}
if (active && !finished) {
do.call(reporter$finish, args = args)
} else {
if (debug) {
why <- if (!active && !finished) {
"not active"
} else if (!active && finished) {
"not active and already finished"
} else if (active && finished) {
"already finished"
}
message(sprintf("- Hmm ... got a request to 'finish' handler, but it's %s. Oh well, will finish it then", why))
}
}
reset_internal_state()
finished <<- TRUE
if (debug) message("- owner: ", deparse(owner))
.validate_internal_state("finish_reporter() ... done")
if (debug) mprintf("finish_reporter() ... done")
}
is_owner <- function(p) {
progressor_uuid <- p[["progressor_uuid"]]
if (is.null(owner)) owner <<- progressor_uuid
(owner == progressor_uuid)
}
is_duplicated <- function(p) {
progressor_uuid <- p[["progressor_uuid"]]
session_uuid <- p[["session_uuid"]]
progression_index <- p[["progression_index"]]
progression_time <- p[["progression_time"]]
progression_id <- sprintf("%s-%d-%s", session_uuid, progression_index, progression_time)
db <- done[["progressor_uuid"]]
res <- is.element(progression_id, db)
if (!res) {
db <- c(db, progression_id)
done[["progressor_uuid"]] <<- db
}
res
}
if (is.null(handler)) {
handler <- function(p) {
stop_if_not(inherits(p, "progression"))
if (is_fork_child()) return(invisible(FALSE))
if (inherits(p, "control_progression")) {
type <- p[["type"]]
if (type == "reset") {
reset_internal_state()
reset_reporter(p)
.validate_internal_state(sprintf("handler(type=%s) ... end", type))
} else if (type == "shutdown") {
finish_reporter(p)
.validate_internal_state(sprintf("handler(type=%s) ... end", type))
} else if (type == "hide") {
hide_reporter(p)
.validate_internal_state(sprintf("handler(type=%s) ... end", type))
} else if (type == "unhide") {
unhide_reporter(p)
.validate_internal_state(sprintf("handler(type=%s) ... end", type))
} else if (type == "interrupt") {
interrupt_reporter(p)
.validate_internal_state(sprintf("handler(type=%s) ... end", type))
} else {
stop("Unknown control_progression type: ", sQuote(type))
}
.validate_internal_state(sprintf("control_progression ... end", type))
return(invisible(finished))
}
debug <- getOption("progressr.debug", FALSE)
if (!is_owner(p)) {
if (debug) message("- not owner of this progression. Skipping")
return(invisible(finished))
}
duplicated <- is_duplicated(p)
type <- p[["type"]]
if (debug) {
mprintf("Progression calling handler %s ...", sQuote(type))
mprintf("- progression:")
mstr(p)
mprintf("- progressor_uuid: %s", p[["progressor_uuid"]])
mprintf("- progression_index: %s", p[["progression_index"]])
mprintf("- duplicated: %s", duplicated)
}
if (duplicated) {
if (debug) mprintf("Progression calling handler %s ... condition already done", sQuote(type))
return(invisible(finished))
} else if (active && finished) {
if (debug) mprintf("Progression calling handler %s ... active but already finished", sQuote(type))
return(invisible(finished))
}
if (type == "initiate") {
if (active) {
if (debug) message("- cannot 'initiate' handler, because it is already active")
return(invisible(finished))
}
max_steps <<- p[["steps"]]
if (debug) mstr(list(max_steps=max_steps))
stop_if_not(!is.null(max_steps), is.numeric(max_steps), length(max_steps) == 1L, max_steps >= 0)
auto_finish <<- p[["auto_finish"]]
times <- min(times, max_steps)
if (debug) mstr(list(auto_finish = auto_finish, times = times, interval = interval, intrusiveness = intrusiveness))
times <- min(c(times / intrusiveness, max_steps), na.rm = TRUE)
times <- max(times, 1L)
interval <- interval * intrusiveness
if (debug) mstr(list(times = times, interval = interval))
milestones <<- if (times == 1L) {
c(max_steps)
} else if (times == 2L) {
c(0L, max_steps)
} else {
seq(from = 0L, to = max_steps, length.out = times + 1L)[-1]
}
timestamps <<- rep(as.POSIXct(NA), times = max_steps)
timestamps[1] <<- Sys.time()
step <<- 0L
message <<- character(0L)
if (debug) mstr(list(finished = finished, milestones = milestones))
initiate_reporter(p)
prev_milestone <<- step
.validate_internal_state(sprintf("handler(type=%s) ... end", type))
} else if (type == "finish") {
if (debug) mstr(list(finished = finished, milestones = milestones))
finish_reporter(p)
.validate_internal_state("type=finish")
} else if (type == "update") {
if (!active) {
if (debug) message("- cannot 'update' handler, because it is not active")
return(invisible(finished))
}
if (debug) mstr(list(step=step, "p$amount"=p[["amount"]], "p$step"=p[["step"]], max_steps=max_steps))
if (!is.null(p[["step"]])) {
p[["amount"]] <- p[["step"]] - step
}
step <<- min(max(step + p[["amount"]], 0L), max_steps)
stop_if_not(step >= 0L)
msg <- conditionMessage(p)
if (length(msg) > 0) message <<- msg
if (step > 0) timestamps[step] <<- Sys.time()
if (debug) mstr(list(finished = finished, step = step, milestones = milestones, prev_milestone = prev_milestone, interval = interval))
.validate_internal_state("type=update")
if ((length(milestones) > 0L && step >= milestones[1]) ||
p[["amount"]] == 0) {
skip <- FALSE
if (interval > 0 && step > 0) {
dt <- difftime(timestamps[step], timestamps[max(prev_milestone, 1L)], units = "secs")
skip <- (dt < interval)
if (debug) mstr(list(dt = dt, timestamps[step], timestamps[prev_milestone], skip = skip))
}
if (!skip) {
if (debug) mstr(list(milestones = milestones))
update_reporter(p)
if (p[["amount"]] > 0) prev_milestone <<- step
}
if (p[["amount"]] > 0) {
milestones <<- milestones[milestones > step]
if (auto_finish && step == max_steps) {
if (debug) mstr(list(type = "finish (auto)", milestones = milestones))
finish_reporter(p)
}
}
}
.validate_internal_state(sprintf("handler(type=%s) ... end", type))
} else {
stop("Unknown 'progression' type: ", sQuote(type))
}
.validate_internal_state(sprintf("handler() ... end", type))
if (debug) mprintf("Progression calling handler %s ... done", sQuote(type))
invisible(finished)
}
}
class(handler) <- c(sprintf("%s_progression_handler", name),
"progression_handler", "calling_handler",
class(handler))
handler
}
print.progression_handler <- function(x, ...) {
print(sys.calls())
s <- sprintf("Progression calling handler of class %s:", sQuote(class(x)[1]))
env <- environment(x)
s <- c(s, " * configuration:")
s <- c(s, sprintf(" - name: %s", sQuote(env$name %||% "<NULL>")))
s <- c(s, sprintf(" - max_steps: %s", env$max_steps %||% "<NULL>"))
s <- c(s, sprintf(" - enable: %s", env$enable))
s <- c(s, sprintf(" - enable_after: %g seconds", env$enable_after))
s <- c(s, sprintf(" - times: %g", env$times))
s <- c(s, sprintf(" - interval: %g seconds", env$interval))
s <- c(s, sprintf(" - intrusiveness: %g", env$intrusiveness))
s <- c(s, sprintf(" - auto_finish: %s", env$auto_finish))
s <- c(s, sprintf(" - clear: %s", env$clear))
s <- c(s, sprintf(" - target: %s", paste(sQuote(env$target), collapse = ", ")))
s <- c(s, sprintf(" - milestones: %s", hpaste(env$milestones %||% "<NULL>")))
s <- c(s, sprintf(" - owner: %s", hpaste(env$owner %||% "<NULL>")))
s <- c(s, " * state:")
s <- c(s, sprintf(" - enabled: %s", env$enabled))
s <- c(s, sprintf(" - finished: %s", env$finished))
s <- c(s, sprintf(" - step: %s", env$step %||% "<NULL>"))
s <- c(s, sprintf(" - message: %s", env$message %||% "<NULL>"))
s <- c(s, sprintf(" - prev_milestone: %s", env$prev_milestone %||% "<NULL>"))
s <- c(s, sprintf(" - delta: %g", (env$step - env$prev_milestone) %||% 0L))
s <- c(s, sprintf(" - timestamps: %s", hpaste(env$timestamps %||% "<NULL>")))
s <- paste(s, collapse = "\n")
cat(s, "\n", sep = "")
}
handler_backend_args <- function(...) {
args <- list(...)
if (length(args) == 0L) return(list())
names <- names(args)
if (is.null(names) || !all(nzchar(names))) {
stop("Additional arguments must be named")
}
names <- setdiff(names, names(formals(make_progression_handler)))
args[names]
}
|
test_that("kinshipLR() catches input errors", {
s = singleton(1)
expect_error(kinshipLR(s), "The input must contain at least two pedigrees")
expect_error(kinshipLR(list(s)), "The input must contain at least two pedigrees")
expect_error(kinshipLR(list(s, 1)), "The input is not a list of pedigrees")
expect_error(kinshipLR(list(s, s)), "None of the pedigrees")
expect_error(kinshipLR(s, s), "None of the pedigrees")
expect_error(kinshipLR(s, s, source = 1), "The source pedigree has no attached markers")
expect_error(kinshipLR(list(s, s), source = 1), "The source pedigree has no attached markers")
s1 = setMarkers(s, marker(s))
expect_error(kinshipLR(s1, s1, ref = 3), "Invalid value for `ref`")
expect_error(kinshipLR(s1, s1, ref = 0), "Invalid value for `ref`")
expect_error(kinshipLR(s1, s1, ref = "unrel"), "Invalid value for `ref`")
expect_error(kinshipLR(a=s, a=s1), "Duplicated hypothesis name")
expect_error(kinshipLR(s, H1=s1), "Duplicated hypothesis name")
s2 = setMarkers(s, list(marker(s), marker(s)))
expect_error(kinshipLR(s1, s2), "When `markers = NULL`, all pedigrees must have the same number of attached markers")
})
test_that("kinshipLR() computes correctly in paternity case", {
H1 = nuclearPed(fa = "fa", child = "ch")
H2 = list(singleton("fa"), singleton("ch"))
m = marker(H1, fa = "A/A", ch = "A/A", afreq = c(A=0.05, B=0.95))
H1 = setMarkers(H1, m)
lr = kinshipLR(H1, H2)$LRtotal[[1]]
expect_equal(lr, 20)
})
|
topgenes_extract <- function(generes, padj = 0.05, FC = 1.5, topNum = 30) {
if(class(generes) != "list") {
stop("generes must be of class list.")
}
if(all(is.numeric(padj), is.numeric(FC), is.numeric(topNum))[1] == FALSE) {
stop("padj, FC, and topNum must all be of class numeric.")
}
if(is.null(generes[[1]]$avg_logFC)) {
message("Seurat V4 or later was used to identify cell-type markers, adding 'avg_logFC' column. It has the same data as avg_log2FC but is compatible with downstream functions in scMappR.")
for(z in 1:length(generes))
generes[[z]]$avg_logFC <- generes[[z]]$avg_log2FC
}
topGenes <- list()
for(i in 1:length(generes)) {
genes <- rownames(generes[[i]])[generes[[i]]$avg_logFC > log2(FC) & generes[[i]]$p_val_adj < padj]
if(length(genes) > topNum) {
genes <- genes[1:topNum]
}
topGenes[[i]] <- genes
}
names(topGenes) <- names(generes)
return(topGenes)
}
|
rm(list=ls(all=TRUE))
if (!require(DBI)) install.packages("DBI")
if (!require(RSQLite)) install.packages("RSQLite")
if (!require(ggplot2)) install.packages("ggplot2")
if (!require(grid)) install.packages("grid")
if (!require(corrplot)) install.packages("corrplot")
if (!require(zoo)) install.packages("zoo")
if (!require(magrittr)) install.packages("magrittr")
library(DBI)
library(ggplot2)
library(grid)
library(corrplot)
library(zoo)
library(magrittr)
library(dbConnect)
con <- dbConnect(RSQLite::SQLite(), dbname='database.db')
currencies <- dbGetQuery(con, "SELECT * FROM currency")
vals <- dbGetQuery(con, "SELECT * FROM val")
rm(con)
vals$id <- NULL
currencies$id <- NULL
vals$datetime <- as.Date(vals$datetime)
vals <- vals[!duplicated(vals[,6:7]),]
interpolate.missing.data <- function(data) {
currencies <- unique(data$currency_slug)
newrows <- do.call("rbind", lapply(currencies, FUN=missing.date.rows, data))
data <- rbind(data, newrows)
data <- data[order(data$currency_slug,data$datetime),]; rownames(data) <- 1:nrow(data)
for (currency in currencies) {
idx <- colSums(!is.na(data[data$currency_slug==currency,1:5])) > 1
data[data$currency_slug==currency,c(idx,FALSE,FALSE)] <- na.approx(data[data$currency_slug==currency,c(idx,FALSE,FALSE)], na.rm=FALSE)
}
return(data)
}
missing.date.rows <- function(currency, data) {
dates <- unique(data[data$currency_slug==currency,6])
alldates <- seq(dates[1],dates[length(dates)],by="+1 day")
missingdates <- setdiff(alldates, dates)
return(data.frame(price_usd=rep(NA, length(missingdates)),
price_btc=rep(NA, length(missingdates)),
volume_usd=rep(NA, length(missingdates)),
market_cap_usd=rep(NA, length(missingdates)),
available_supply=rep(NA, length(missingdates)),
datetime=as.Date(missingdates, origin="1970-01-01"),
currency_slug=rep(currency, length(missingdates))))
}
vals <- interpolate.missing.data(vals)
market.data <- function(data) {
dates <- sort(unique(data$datetime))
cap <- sapply(dates, FUN=function(date) sum(data[data$datetime==date,4]))
returns <- c(0,diff(cap)/cap[-length(cap)])
logreturns <- c(0,log(cap[-1]/cap[-length(cap)]))
volatility.30d <- sapply(1:length(logreturns), FUN=function(i) sd(logreturns[(max(i-30,0):i)]))*sqrt(365)
volatility.90d <- sapply(1:length(logreturns), FUN=function(i) sd(logreturns[(max(i-90,0):i)]))*sqrt(365)
herfindahl <- sapply(dates, FUN=function(date) sum((data[vals$datetime==date,4]/sum(data[data$datetime==date,4]))^2))
data.frame(datetime=dates, cap=cap, return=returns, logreturn=logreturns, volatility.30d=volatility.30d, volatility.90d=volatility.90d, herfindahl=herfindahl)
}
market <- market.data(vals)
plot.market <- function(market) {
p1 <- ggplot(market, aes(datetime, cap)) +
geom_line() +
labs(x="Date", y="Market cap", title="Overall market") +
theme(axis.title.x=element_blank(), axis.text.x=element_blank(), axis.ticks.x=element_blank())
p2 <- ggplot(market, aes(datetime, logreturn)) +
geom_line() +
labs(x="Date", y="Log return") +
theme(axis.title.x=element_blank(), axis.text.x=element_blank(), axis.ticks.x=element_blank())
p3 <- ggplot(market, aes(datetime, volatility.30d)) +
geom_line() +
labs(x="Date", y="Annualized volatility") +
theme(axis.title.x=element_blank(), axis.text.x=element_blank(), axis.ticks.x=element_blank())
p4 <- ggplot(market, aes(datetime, herfindahl)) + geom_line() + labs(x="Date", y="Herfindahl index")
library(gtable)
library(grid)
g1 <- ggplotGrob(p1)
g2 <- ggplotGrob(p2)
g3 <- ggplotGrob(p3)
g4 <- ggplotGrob(p4)
g <- rbind(g1, g2, g3, g4, size="first")
g$widths <- unit.pmax(g1$widths, g2$widths, g3$widths, g4$widths)
g$layout[grepl("guide", g$layout$name),c("t","b")] <- c(1,nrow(g))
grid.newpage()
grid.draw(g)
ggsave("Market-statistics.png", g, width=8, height=6, dpi=100, units="in")
}
plot.market(market)
currencies$mcap <- sapply(currencies$slug, FUN=function(x) vals[vals$currency_slug==x & vals$datetime==max(vals[vals$currency_slug==x,]$datetime),]$market_cap_usd)
currencies <- currencies[order(currencies$mcap,currencies$slug, decreasing=TRUE),]; rownames(currencies) <- 1:nrow(currencies)
vals$return <- Reduce(c,sapply(unique(vals$currency_slug), FUN=function(x) c(0,diff(vals[vals$currency_slug==x,]$price_usd)/(vals[vals$currency_slug==x,]$price_usd)[-length(vals[vals$currency_slug==x,]$price_usd)])))
vals$logreturn <- Reduce(c,sapply(unique(vals$currency_slug), FUN=function(x) c(0,log(vals[vals$currency_slug==x,]$price_usd[-1]/vals[vals$currency_slug==x,]$price_usd[-length(vals[vals$currency_slug==x,]$price_usd)]))))
plot.currency <- function(data, slug) {
data <- data[data$currency_slug==slug,]
data$volatility.30d <- sapply(1:nrow(data), FUN=function(i) sd(data$logreturn[(max(i-30,0):i)]))*sqrt(365)
p1 <- ggplot(data, aes(datetime, market_cap_usd)) +
geom_line() +
labs(x="Date", y="Market cap", title=slug) +
theme(axis.title.x=element_blank(), axis.text.x=element_blank(), axis.ticks.x=element_blank())
p2 <- ggplot(data, aes(datetime, logreturn)) +
geom_line() + labs(x="Date", y="Log return") +
theme(axis.title.x=element_blank(), axis.text.x=element_blank(), axis.ticks.x=element_blank())
p3 <- ggplot(data, aes(datetime, volatility.30d)) + geom_line() + labs(x="Date", y="Annualized volatility")
library(gtable)
library(grid)
g1 <- ggplotGrob(p1)
g2 <- ggplotGrob(p2)
g3 <- ggplotGrob(p3)
g <- rbind(g1, g2, g3, size="first")
g$widths <- unit.pmax(g1$widths, g2$widths, g3$widths)
g$layout[grepl("guide", g$layout$name),c("t","b")] <- c(1,nrow(g))
grid.newpage()
grid.draw(g)
ggsave("Bitcoin-statistics.png", g, width=8, height=6, dpi=100, units="in")
}
plot.currency(vals, "bitcoin")
plot.currencies <- function(data, slugs) {
data <- data[data$currency_slug %in% slugs,]
data$volatility.30d <- Reduce(c,sapply(unique(data$currency_slug), FUN=function(x) sapply(1:length(data[data$currency_slug==x,]$logreturn), FUN=function(i) sd(data[data$currency_slug==x,]$logreturn[(max(i-30,0):i)]))))*sqrt(365)
p1 <- ggplot(data, aes(datetime, market_cap_usd, color=factor(currency_slug))) +
geom_line() +
labs(x="Date", y="Market cap", title=paste(slugs, collapse=", ")) +
theme(axis.title.x=element_blank(), axis.text.x=element_blank(), axis.ticks.x=element_blank(), legend.title=element_blank())
p2 <- ggplot(data, aes(datetime, logreturn, color=factor(currency_slug))) +
geom_line() +
labs(x="Date", y="Log return") +
theme(axis.title.x=element_blank(), axis.text.x=element_blank(), axis.ticks.x=element_blank(), legend.title=element_blank())
p3 <- ggplot(data, aes(datetime, volatility.30d, color=factor(currency_slug))) +
geom_line() +
labs(x="Date", y="Annualized volatility")
library(gtable)
library(grid)
g1 <- ggplotGrob(p1)
g2 <- ggplotGrob(p2)
g3 <- ggplotGrob(p3)
g <- rbind(g1, g2, g3, size="first")
g$widths <- unit.pmax(g1$widths, g2$widths, g3$widths)
g$layout[grepl("guide", g$layout$name),c("t","b")] <- c(1,nrow(g))
grid.newpage()
grid.draw(g)
ggsave("Coin-statistics.png", g, width=8, height=6, dpi=100, units="in")
}
plot.currencies(vals, c("bitcoin","ethereum", "ripple"))
analysis.data <- function(currencies, data, market=NULL) {
temp <- lapply(currencies, FUN=function(x) subset(data, currency_slug==x))
temp <- Reduce(function(df1, df2) merge(df1, df2, by="datetime"), temp)
if (length(currencies) > 1)
colnames(temp) <- c("datetime", sapply(currencies, function(slug) sapply(colnames(data)[c(1:5,7:9)], function(x) paste(x, slug, sep="_"))))
if (!is.null(market))
temp <- merge(temp, market, by="datetime")
data.frame(temp)
}
plot.return.vs.return <- function(currency1, currency2, data) {
data <- analysis.data(c(currency1, currency2), data)
cor_ <- cor(data[[paste("logreturn_",currency1,sep="")]], data[[paste("logreturn_",currency2,sep="")]])
p <- ggplot(data, aes_string(x=paste("logreturn_",currency1,sep=""), y=paste("logreturn_",currency2,sep="")))
p + geom_point() +
labs(title=paste("Returns: ",currency1," vs ",currency2," (cor = ",round(cor_, digits=4),")",sep=""), x=paste(currency1, "Return"), y=paste(currency2, "Return")) +
theme(legend.title=element_blank())
ggsave("Bitcoin-vs-ethereum-returns.png", width=8, height=4, dpi=100, units="in")
}
plot.return.vs.return("bitcoin", "ethereum", vals[vals$datetime>as.Date("2017-12-31"),])
analysis.return.data <- function(currencies, data) {
data <- reshape(data[data$currency_slug %in% currencies,c(6,7,9)], direction="wide", idvar="datetime", timevar="currency_slug")
colnames(data) <- c("datetime", sort(currencies))
data <- data[,c("datetime", currencies)]
return(data)
}
png(filename="Corrplot.png", width=800, height=700, units="px")
corrplot(cor(analysis.return.data(currencies[1:25,]$slug,vals[vals$datetime>as.Date("2017-12-31"),])[,-1],
use = "pairwise.complete.obs"), method="ellipse")
dev.off()
plot.corr.timeline <- function(currency1, currency2, mindays, maxdays, data) {
data <- analysis.data(c(currency1, currency2), data)
data$corr <- sapply(1:nrow(data), FUN=function(i) if(i<mindays) return(NA) else cor(data[max(1,i-maxdays):i,9],data[max(1,i-maxdays):i,17]))
p <- ggplot(data, aes(datetime, corr))
p + geom_line() + labs(x="Date", y="Correlation", title=paste("Correlation timeline: ", paste(c(currency1, currency2), collapse=", ")))
ggsave("Corr-timeline.png", width=8, height=4, dpi=100, units="in")
}
plot.corr.timeline("bitcoin", "ethereum", 30, 90, vals)
plot.return.vs.market <- function(currency, data, market) {
data <- analysis.data(currency, data, market)
cor_ <- cor(data$logreturn.x, data$logreturn.y)
p <- ggplot(data, aes(x=logreturn.x, y=logreturn.y))
p + geom_point() +
labs(title=paste("Returns: ",currency," vs Market (cor = ",round(cor_, digits=4),")",sep=""), x=paste(currency, "return"), y="Market return") +
theme(legend.title=element_blank())
ggsave("Ethereum-vs-market-return.png", width=8, height=4, dpi=100, units="in")
}
plot.return.vs.market("ethereum", vals[vals$datetime>as.Date("2017-12-31"),], market)
currency.beta <- function(currency, data, market) {
dates <- intersect(data[data$currency_slug==currency,]$datetime, market$datetime)
return(cov(data[data$currency_slug==currency & data$datetime %in% dates,]$logreturn,
market[market$datetime %in% dates,]$logreturn)/var(market[market$datetime %in% dates,]$logreturn))
}
currencies$beta <- sapply(currencies$slug, FUN=currency.beta, vals[vals$datetime>as.Date("2017-12-31"),], market)
plot.beta.vs.mcap.num <- function(num, currencies) {
data <- currencies[order(currencies$mcap, decreasing=TRUE),]
data <- data[0:num,]
p <- ggplot(data, aes(x=mcap, y=beta))
p + geom_point() +
scale_x_log10() +
geom_text(aes(label=name),hjust=0, vjust=0) +
labs(title="Beta vs Market capitalisation", x="Market capitalisation [USD] (log scale)", y="Beta") +
theme(legend.title=element_blank())
ggsave("Beta-vs-mcap.png", width=8, height=5, dpi=100, units="in")
}
plot.beta.vs.mcap.num(25, currencies)
plot.beta.timeline <- function(currencies, mindays, maxdays, data, market) {
data <- data[data$currency_slug %in% currencies,]
dates <- intersect(data$datetime, market$datetime)
result <- data.frame(datetime=as.Date(rep(dates, times=length(currencies)), origin="1970-01-01"), currency=rep(currencies,each=length(dates)))
result$beta <- Reduce(c, sapply(currencies,
function(currency) sapply(dates,
function(date) if(nrow(data[data$currency_slug==currency & date-maxdays<data$datetime & data$datetime<=date,])<mindays) return(NA) else currency.beta(currency, data[data$currency_slug==currency & date-maxdays<data$datetime & data$datetime<=date,], market))))
p <- ggplot(result, aes(datetime, beta, color=factor(currency)))
p + geom_line() + labs(x="Date", y="Beta", title=paste("Beta timeline: ", paste(currencies, collapse=", "))) + theme(legend.title=element_blank())
ggsave("Beta-timeline.png", width=8, height=4, dpi=100, units="in")
}
plot.beta.timeline(c("bitcoin","ethereum","ripple"), 30, 90, vals, market)
|
surfaceIndex<-function(Daily){
localDaily <- Daily
bottomLogQ<- min(localDaily$LogQ, na.rm = TRUE) - 0.05
topLogQ <- max(localDaily$LogQ, na.rm = TRUE) + 0.05
stepLogQ <-(topLogQ-bottomLogQ)/13
vectorLogQ <- seq(bottomLogQ,topLogQ,stepLogQ)
stepYear<-1/16
bottomYear<-floor(min(localDaily$DecYear, na.rm = TRUE))
topYear<-ceiling(max(localDaily$DecYear, na.rm = TRUE))
vectorYear<-seq(bottomYear,topYear,stepYear)
nVectorYear<-length(vectorYear)
surfaceIndexParameters<-list(bottomLogQ=bottomLogQ,
stepLogQ=stepLogQ,
nVectorLogQ=14,
bottomYear=bottomYear,
stepYear=stepYear,
nVectorYear=nVectorYear,
vectorYear=vectorYear,
vectorLogQ=vectorLogQ)
return(surfaceIndexParameters)
}
|
library(knitr)
options(rmarkdown.html_vignette.check_title = FALSE)
knitr::opts_chunk$set(echo = TRUE,
eval=TRUE,
tidy = FALSE,
cache = FALSE,
warning = FALSE,
message = FALSE,
dpi = 60)
library(manhattanly)
set.seed(12345)
HapMap.subset <- subset(HapMap, CHR %in% 4:7)
significantSNP <- sample(HapMap.subset$SNP, 20)
head(HapMap.subset)
dim(HapMap.subset)
manhattanrObject <- manhattanr(HapMap)
str(manhattanrObject)
head(manhattanrObject[["data"]])
is.data.frame(manhattanrObject[["data"]])
manhattanrObject <- manhattanr(HapMap, snp = "SNP", gene = "GENE",
annotation1 = "DISTANCE", annotation2 = "EFFECTSIZE")
head(manhattanrObject[["data"]])
is.data.frame(manhattanrObject[["data"]])
qqrObject <- qqr(HapMap)
str(qqrObject)
head(qqrObject[["data"]])
volcanorObject <- volcanor(HapMap,
p = "P",
effect_size = "EFFECTSIZE",
snp = "SNP",
gene = "GENE")
str(volcanorObject)
head(volcanorObject[["data"]])
|
context("tests the plotAncStatesPie function")
test_that("plots pies of ancestral states", {
tree_file <-
system.file("extdata",
"dec/small_dec.tre",
package = "RevGadgets")
plot_file <-
system.file("extdata",
"graphs/plotAncStatesPie_df.rds",
package = "RevGadgets")
labs <- c(
"1" = "K",
"2" = "O",
"3" = "M",
"4" = "H",
"5" = "KO",
"6" = "KM",
"7" = "OM",
"8" = "KH",
"9" = "OH",
"10" = "MH",
"11" = "KOM",
"12" = "KOH",
"13" = "KMH",
"14" = "OMH",
"15" = "KOMH"
)
dec_example <- processAncStates(tree_file , state_labels = labs)
colors <-
colorRampPalette(colFun(12))(length(dec_example@state_labels))
names(colors) <- dec_example@state_labels
plot_new <-
plotAncStatesPie(
t = dec_example,
pie_colors = colors,
tip_labels_size = 2,
cladogenetic = TRUE,
tip_labels_offset = 0.01,
timeline = F,
node_pie_size = .5,
tip_pie_size = .3
) +
ggplot2::scale_x_continuous(limits = c(-0.5, 1)) +
ggplot2::theme(legend.position = c(0.1, 0.75))
plot_orig <- readRDS(plot_file)
tmp <- tempdir()
pdf(paste0(tmp,"/Rplots.pdf"))
expect_error(print(plot_new), NA)
dev.off()
expect_equal(plot_new$data, plot_orig)
})
|
library(portfolio)
load("portfolio.performance.test.RData")
result <- performance(test.portfolio, test.market.data)
empty.result <- performance(empty.portfolio, test.market.data)
row.names([email protected]) <- as.character(row.names([email protected]))
stopifnot(
all.equal(result@ret, truth@ret),
all.equal(result@profit, truth@profit),
all.equal([email protected], [email protected]),
all.equal([email protected], [email protected]),
all.equal([email protected], [email protected]),
all.equal([email protected], [email protected]),
all.equal(empty.result, empty.truth)
)
|
banding.cv <- function(matrix, n.cv = 10, norm = "F", seed = 142857) {
if ((norm %in% c("F","O","f","o")) == FALSE) {
stop("This function only support two norm: Frobenius and operator")
}
banding.loss <- function(mat1, mat2, k, norm) {
cov.mat1 <- cov(mat1)
cov.mat2 <- cov(mat2)
mat.diff <- banding(cov.mat1, k) - cov.mat2
if (norm %in% c("F","f")) {
loss <- F.norm2(mat.diff)
} else if (norm %in% c("O","o")) {
loss <- O.norm2(mat.diff)
}
return(loss)
}
N <- dim(matrix)[1]
n1 <- ceiling(N*(1 - 1/log(N)))
n2 <- floor(N/log(N))
k.grid <- 0:(ncol(matrix) - 1)
loss.mat <- matrix(0, nrow = n.cv, ncol = length(k.grid))
for (i in 1:n.cv) {
set.seed(seed + i)
index <- sample(1:N, size = n1, replace = FALSE)
mat1 <- matrix[index,]
mat2 <- matrix[-index,]
loss.mat[i,] <- sapply(k.grid, FUN = banding.loss, mat1 = mat1, mat2 = mat2, norm = norm)
}
loss.vec <- colMeans(loss.mat)
k.opt <- k.grid[which.min(loss.vec)]
result <- list(regularization = "Banding",
parameter.opt = k.opt,
cv.error = loss.vec,
n.cv = n.cv, norm = norm, seed = seed
)
class(result) <- "CovCv"
return(result)
}
|
q10_bidabe <- function(x, total=TRUE){
cq10 = 3
y <- rep(0, length(x))
y <- (1/24)*cq10^(-x/10)
if (total==TRUE)
return(tail(cumsum(y),n=1))
else return(y)
}
|
`Wnet` <-
function(add=FALSE, col = gray(.7), border='black', lwd=1)
{
if(missing(add)) { add=FALSE }
if(missing(col)) { col = gray(.7) }
if(missing(lwd)) { lwd=1 }
if(missing(border)) { border='black' }
if(add==FALSE)
{
plot(c(-1,1),c(-1,1), type='n', xlab='', ylab='', asp=1, axes=FALSE, ann=FALSE)
}
pcirc(gcol=col, border=border, ndiv=72)
lam = pi*seq(from=0, to=180, by=5)/180
lam0 = pi/2
for(j in seq(from=-80, to=80, by=10))
{
phi = j*pi/180
R = 1/2
k = 2/(1+cos(phi)*cos(lam-lam0))
x = R*k*cos(phi)*sin(lam-lam0)
y = R * k*sin(phi)
lines(x,y, col=col, lwd=lwd)
}
phi = seq(from=-90, to=90, by=5)*pi/180
for(j in seq(from=10, to=170, by=10))
{
lam = j*pi/180
R = 1/2
k = 2/(1+cos(phi)*cos(lam-lam0))
x = R*k*cos(phi)*sin(lam-lam0)
y = R * k*sin(phi)
lines(x,y, col=col, lwd=lwd)
}
segments(c(-.02, 0), c(0, -0.02), c(0.02, 0), c(0, 0.02), col='black' )
}
|
indicator_plrange <- function(mat,
merge = FALSE,
xmin_bounds = NULL) {
if ( !merge && is.list(mat) ) {
return( lapply(mat, indicator_plrange, merge, xmin_bounds) )
}
psd <- patchsizes(mat, merge = merge)
if ( is.null(xmin_bounds) ) {
xmin_bounds <- range(psd)
}
if ( length(unique(psd)) <= 2 ) {
warning('Not enough different patch sizes to estimate xmin: returning NA')
result <- data.frame(min(psd), max(psd), NA, NA)
} else {
plrange_result <- plrange(psd, xmin_bounds)
result <- data.frame(min(psd), max(psd), plrange_result)
}
names(result) <- c("minsize", "maxsize", "xmin_est", "plrange")
return(result)
}
raw_plrange <- function(mat, xmin_bounds = NULL) {
psd <- patchsizes(mat)
if ( is.null(xmin_bounds) ) {
xmin_bounds <- range(psd)
}
plrange_result <- plrange(psd, xmin_bounds)
return( c(plrange = plrange_result[ ,"plrange"]) )
}
plrange <- function(psd, xmin_bounds) {
if ( length(unique(psd)) <= 1) {
return( data.frame(xmin_est = NA_real_, plrange = NA_real_) )
}
xsmallest <- min(psd)
xmax <- max(psd)
xmin <- xmin_estim(psd, bounds = xmin_bounds)
if ( is.na(xmin) ) {
result <- data.frame(NA_real_, NA_real_)
} else {
result <- data.frame(xmin, 1 - (log10(xmin) - log10(xsmallest)) /
(log10(xmax) - log10(xsmallest)))
}
names(result) <- c('xmin_est', 'plrange')
return(result)
}
|
hedModel <- function(estimator,
hed_df,
hed_spec,
...){
if (!'heddata' %in% class(hed_df)){
message('\nIncorrect class for "hed_df" object. Must be of class "hed"')
stop()
}
if (!paste0('hedModel.', class(estimator)) %in% utils::methods(hedModel)){
message('\nInvalid estimator type: "', class(estimator), '" method not available.')
stop()
}
if (nrow(hed_df) < nrow(attr(hed_df, 'period_table'))){
message('\nYou have fewer observations (', nrow(hed_df), ') than number of periods (',
nrow(attr(hed_df, 'period_table')), '). Results will likely be unreliable.')
}
UseMethod("hedModel", estimator)
}
hedModel.base <- function(estimator,
hed_df,
hed_spec,
...){
hed_model <- stats::lm(hed_spec,
data=hed_df)
class(hed_model) <- 'hedmodel'
hed_model
}
hedModel.robust <- function(estimator,
hed_df,
hed_spec,
...){
time_size <- stats::median(table(hed_df$trans_period))
if(time_size > 5){
hed_model <- MASS::rlm(hed_spec, data=hed_df)
} else {
hed_model <- robustbase::lmrob(hed_spec, data=hed_df, setting="KS2014")
}
class(hed_model) <- 'hedmodel'
hed_model
}
hedModel.weighted <- function(estimator,
hed_df,
hed_spec,
...){
wgts <- list(...)$weights
if (length(wgts) != nrow(hed_df)){
wgts <- rep(1, nrow(hed_df))
message('You have supplied a set of weights that do not match the data.',
'Model being run in base OLS format.')
}
attr(hed_spec, '.Environment') <- environment()
hed_model <- stats::lm(stats::as.formula(hed_spec), data=hed_df, weights=wgts)
class(hed_model) <- 'hedmodel'
hed_model
}
|
pkg_ref_cache.news <- function(x, name, ...) {
UseMethod("pkg_ref_cache.news")
}
pkg_ref_cache.news.pkg_remote <- function(x, name, ...) {
suppressMatchingConditions(
lapply(x$news_urls, function(news_url) {
response <- httr::GET(news_url)
httr::content(
response,
type = response$headers$`content-type` %||% "text/html")
}),
messages = "default")
}
pkg_ref_cache.news.pkg_install <- function(x, name, ...) {
news_from_dir(system.file(package = x$name))
}
pkg_ref_cache.news.pkg_source <- function(x, name, ...) {
news_from_dir(x$path)
}
news_from_dir <- function(path) {
files <- list.files(path, pattern = "^NEWS\\.", full.names = TRUE)
if (!length(files)) return(list())
content <- rep(list(NULL), length(files))
names(content) <- files
valid <- vector(length(files), mode = "logical")
for (i in seq_along(files)) {
f <- files[[i]]
tryCatch({
if (tolower(tools::file_ext(f)) == "rd") {
content[[i]] <- .tools()$.news_reader_default(f)
} else if (tolower(tools::file_ext(f)) == "md") {
content[[i]] <- readLines(f)
}
valid[[i]] <- TRUE
}, error = function(e) {
valid[[i]] <- FALSE
})
}
content[valid]
}
|
ACont.<-function(x,h,n,i=0.04,data,prop=1,assumption="UDD",cap=1){
dig<-getOption("digits")
on.exit(options(digits = dig))
options(digits = 15)
if(x>=0 && is_integer(x)==1 && h>=0 && is_integer(h)==1 && n>=0 && is_integer(n)==1 && i>=0 && prop>0){
if(n==0){
Axhnc<-0
return(Axhnc)
}else{
delta<-log(1+i)
if(assumption=="constant"){
Axhnc<-E(x,h,i,data,prop)-E(x,h+n,i,data,prop,"none",1)-delta*aCont(x,h,n,i,data,prop,"constant",1)
}else if(assumption=="UDD"){
Axhnc<-(i/delta)*A.(x,h,n,1,i,data,prop,"none",1)
}else{
stop("Check assumption")
}
}
Axhnc<-as.numeric(Axhnc)
px1<-Axhnc*cap
return(px1)
}else{
stop("Check Values")
}
}
|
NULL
appsync <- function(config = list()) {
svc <- .appsync$operations
svc <- set_config(svc, config)
return(svc)
}
.appsync <- list()
.appsync$operations <- list()
.appsync$metadata <- list(
service_name = "appsync",
endpoints = list("*" = list(endpoint = "appsync.{region}.amazonaws.com", global = FALSE), "cn-*" = list(endpoint = "appsync.{region}.amazonaws.com.cn", global = FALSE), "us-iso-*" = list(endpoint = "appsync.{region}.c2s.ic.gov", global = FALSE), "us-isob-*" = list(endpoint = "appsync.{region}.sc2s.sgov.gov", global = FALSE)),
service_id = "AppSync",
api_version = "2017-07-25",
signing_name = "appsync",
json_version = "1.1",
target_prefix = ""
)
.appsync$service <- function(config = list()) {
handlers <- new_handlers("restjson", "v4")
new_service(.appsync$metadata, handlers, config)
}
|
gridPrint <- function(...){
arg <- list(...)
ii <- unlist( lapply(arg, inherits, what = "plotSmooth") )
if ( length(ii) ) {
arg[ii] <- lapply(arg[ii], "[[", "ggObj")
}
if( !is.null(arg$grobs) ){
ii <- unlist( lapply(arg$grobs, inherits, what = "plotSmooth") )
if ( length(ii) ) {
arg$grobs[ii] <- lapply(arg$grobs[ii], "[[", "ggObj")
}
}
out <- do.call("grid.arrange", arg)
return( invisible(out) )
}
|
context("expose-helpers")
test_that("guess_pack_type works", {
expect_identical(guess_pack_type(input_data_pack_out), "data_pack")
expect_identical(guess_pack_type(input_group_pack_out), "group_pack")
expect_identical(guess_pack_type(input_col_pack_out), "col_pack")
expect_identical(guess_pack_type(input_row_pack_out), "row_pack")
expect_identical(guess_pack_type(input_cell_pack_out), "cell_pack")
input_col_pack_out_1 <- input_col_pack_out
names(input_col_pack_out_1) <-
gsub("\\._\\.", "\\.___\\.", names(input_col_pack_out_1))
expect_identical(
guess_pack_type(
input_col_pack_out_1,
inside_punct("\\.___\\.")
),
"col_pack"
)
})
test_that("remove_obeyers works", {
input_report <- tibble::tibble(
pack = rep("data_pack", 4), rule = paste0("rule__", 1:4),
var = rep(".all", 4), id = rep(0L, 4),
value = c(TRUE, FALSE, TRUE, NA)
)
expect_identical(remove_obeyers(input_report, FALSE), input_report)
expect_identical(remove_obeyers(input_report, TRUE), input_report[c(2, 4), ])
})
test_that("impute_exposure_pack_names works with NULL reference exposure", {
expect_identical(
impute_exposure_pack_names(input_single_exposures, input_exposure_ref),
input_single_exposures
)
cur_input_single_exposures <- input_single_exposures
names_remove_inds <- c(1, 2, 3, 5, 6, 8)
names(cur_input_single_exposures)[names_remove_inds] <-
rep("", length(names_remove_inds))
expect_identical(
names(impute_exposure_pack_names(cur_input_single_exposures, NULL)),
c(
"data_pack__1", "cell_pack__1", "col_pack__1", "new_col_proper_sums",
"data_pack__2", "row_pack__1", "another_data_pack", "group_pack__1"
)
)
})
test_that("impute_exposure_pack_names works with not NULL reference exposure", {
cur_input_single_exposures <- input_single_exposures
names_remove_inds <- c(1, 2, 3, 5, 6, 8)
names(cur_input_single_exposures)[names_remove_inds] <-
rep("", length(names_remove_inds))
expect_identical(
names(impute_exposure_pack_names(
cur_input_single_exposures,
input_exposure_ref
)),
c(
"data_pack__3", "cell_pack__2", "col_pack__3", "new_col_proper_sums",
"data_pack__4", "row_pack__2", "another_data_pack", "group_pack__2"
)
)
})
test_that("add_pack_names works", {
expect_identical(
add_pack_names(input_single_exposures),
input_exposures
)
})
test_that("bind_exposures works", {
expect_identical(
bind_exposures(list(input_exposure_ref, NULL)),
input_exposure_ref
)
expect_identical(
bind_exposures(list(NULL, NULL)),
NULL
)
output_ref <- new_exposure(
.packs_info = new_packs_info(
rep(input_exposure_ref$packs_info$name, 2),
c(input_exposure_ref$packs_info$fun, input_exposure_ref$packs_info$fun),
rep(input_exposure_ref$packs_info$remove_obeyers, 2)
),
.report = bind_rows(
input_exposure_ref$report,
input_exposure_ref$report
) %>%
add_class_cond("ruler_report")
)
expect_identical(
bind_exposures(list(input_exposure_ref, input_exposure_ref)),
output_ref
)
expect_identical(
bind_exposures(input_exposure_ref, input_exposure_ref),
output_ref
)
})
test_that("filter_not_null works", {
input <- list(NULL, 1, list(2), NULL, "a", "b", list(NULL))
output_ref <- input[-c(1, 4)]
expect_identical(filter_not_null(input), output_ref)
})
test_that("assert_pack_out_one_row works", {
expect_silent(assert_pack_out_one_row(input_data_pack_out, "data_pack"))
expect_error(
assert_pack_out_one_row(input_row_pack_out, "row_pack"),
"row_pack.*not.*row"
)
})
test_that("assert_pack_out_all_logical works", {
expect_silent(assert_pack_out_all_logical(input_data_pack_out, "data_pack"))
input_bad <- tibble::tibble(good = c(TRUE, FALSE), bad = 1:2)
expect_error(
assert_pack_out_all_logical(input_bad, "cell_pack"),
"cell_pack.*not.*logical"
)
})
test_that("assert_pack_out_all_have_separator works", {
expect_silent(
assert_pack_out_all_have_separator(
input_col_pack_out, "col_pack", inside_punct("\\._\\.")
)
)
expect_error(
assert_pack_out_all_have_separator(
input_data_pack_out, "data_pack", inside_punct("\\._\\.")
),
"data_pack.*not.*separator"
)
expect_error(
assert_pack_out_all_have_separator(
input_col_pack_out, "col_pack", inside_punct("\\.___\\.")
),
"col_pack.*not.*separator"
)
})
|
sim_ail_pedigree <-
function(ngen=12, npairs=30, nkids_per=5, design=c("nosib", "random"))
{
design <- match.arg(design)
id <- c(1,2,3,4, (1:(npairs*2)+4))
mom <- c(0,0,1,1,rep(3, npairs*2))
dad <- c(0,0,2,2,rep(4, npairs*2))
sex <- c(0,1,0,1,rep(c(0,1), npairs))
gen <- c(0,0,1,1,rep(2, npairs*2))
if(ngen <= 2)
stop("No. generations should be > 2")
cur_nind <- length(id)
moms <- seq(5, length(id), by=2)
dads <- seq(6, length(id), by=2)
for(i in 3:ngen) {
if(i > 3) {
dads <- sample(dads)
while(design=="nosib" && any(dads - moms == 1)) {
dads <- sample(dads)
}
}
if(i < ngen) {
kids <- 1:(npairs*2)+max(id)
id <- c(id, kids)
mom <- c(mom, rep(moms, each=2))
dad <- c(dad, rep(dads, each=2))
sex <- c(sex, rep(c(0,1), npairs))
gen <- c(gen, rep(i, npairs*2))
moms <- kids[seq(1, length(kids), by=2)]
dads <- kids[seq(2, length(kids), by=2)]
}
else {
kids <- 1:(npairs*nkids_per)+max(id)
id <- c(id, kids)
mom <- c(mom, rep(moms, each=nkids_per))
dad <- c(dad, rep(dads, each=nkids_per))
sex <- c(sex, rep(c(0,1), ceiling(npairs*nkids_per/2))[1:(npairs*nkids_per)])
gen <- c(gen, rep(i, npairs*nkids_per))
}
}
data.frame(id=id, mom=mom, dad=dad, sex=sex, gen=gen)
}
|
context("Features: ELA - Curvature")
test_that("Require original function", {
set.seed(2015*03*26)
X = t(replicate(n = 2000, expr = runif(n = 5L, min = -10L, max = 10L)))
feat.object = createFeatureObject(X = X, y = rowSums(X^2))
expect_error(calculateFeatureSet(feat.object, "ela_curv"))
})
test_that("Required sample size is too big for the given data", {
set.seed(2015*03*26)
X = t(replicate(n = 100, expr = runif(n = 3L, min = -10L, max = 10L)))
f = function(x) sum(x^2)
feat.object = createFeatureObject(X = X, fun = f)
expect_warning(calculateFeatureSet(feat.object, "ela_curv"))
})
test_that("Expected Output", {
set.seed(2015*03*26)
X = t(replicate(n = 2000L, expr = runif(n = 5L, min = -10L, max = 10L)))
feat.object = createFeatureObject(X = X, fun = function(x) sum(x^2))
features = calculateFeatureSet(feat.object, "ela_curv")
expect_identical(length(features), 26L)
expect_list(features)
expect_identical(as.character(sapply(features, class)),
c(rep("numeric", 24L), "integer", "numeric"))
expect_true(testNumber(features$ela_curv.grad_norm.min, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.lq, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.mean, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.med, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.uq, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.max, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.sd, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.nas, lower = 0L, upper = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.min, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.lq, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.mean, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.med, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.uq, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.max, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.sd, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_scale.nas, lower = 0L, upper = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.min, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.lq, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.mean, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.med, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.uq, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.max, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.sd, lower = 0L))
expect_true(testNumber(features$ela_curv.hessian_cond.nas, lower = 0L, upper = 1L))
expect_true(testNumber(features$ela_curv.costs_fun_evals, lower = 0L))
expect_true(testNumber(features$ela_curv.costs_runtime, lower = 0L))
grad_norm_features = features[grep("grad_norm", names(features))]
x = unlist(grad_norm_features[grep("min|lq|med|uq|max", names(grad_norm_features))])
expect_true(all(diff(x) >= 0L))
x = unlist(grad_norm_features[grep("min|mean|max", names(grad_norm_features))])
expect_true(all(diff(x) >= 0L))
grad_scale_features = features[grep("grad_scale", names(features))]
x = unlist(grad_scale_features[grep("min|lq|med|uq|max", names(grad_scale_features))])
expect_true(all(diff(x) >= 0L))
x = unlist(grad_scale_features[grep("min|mean|max", names(grad_scale_features))])
expect_true(all(diff(x) >= 0L))
hessian_features = features[grep("hessian", names(features))]
x = unlist(hessian_features[grep("min|lq|med|uq|max", names(hessian_features))])
expect_true(all(diff(x) >= 0L))
x = unlist(hessian_features[grep("min|mean|max", names(hessian_features))])
expect_true(all(diff(x) >= 0L))
})
test_that("Expected Output on Bounds", {
X = cbind(x1 = rep(c(0, 10), 2), x2 = rep(c(0, 10), each = 2))
feat.object = createFeatureObject(X = X, fun = function(x) sum(x^2))
features = calculateFeatureSet(feat.object, "ela_curv", control = list(ela_curv.sample_size = 4))
expect_identical(length(features), 26L)
expect_list(features)
expect_identical(as.character(sapply(features, class)),
c(rep("numeric", 24L), "integer", "numeric"))
expect_true(testNumber(features$ela_curv.grad_norm.lq, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.mean, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.med, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.uq, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.max, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.sd, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_norm.nas, lower = 0L, upper = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.min, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.lq, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.mean, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.med, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.uq, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.max, lower = 1L))
expect_true(testNumber(features$ela_curv.grad_scale.sd, lower = 0L))
expect_true(testNumber(features$ela_curv.grad_scale.nas, lower = 0L, upper = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.min, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.lq, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.mean, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.med, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.uq, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.max, lower = 1L))
expect_true(testNumber(features$ela_curv.hessian_cond.sd, lower = 0L))
expect_true(testNumber(features$ela_curv.hessian_cond.nas, lower = 0L, upper = 1L))
expect_true(testNumber(features$ela_curv.costs_fun_evals, lower = 0L))
expect_true(testNumber(features$ela_curv.costs_runtime, lower = 0L))
grad_norm_features = features[grep("grad_norm", names(features))]
x = unlist(grad_norm_features[grep("min|lq|med|uq|max", names(grad_norm_features))])
expect_true(all(diff(x) >= 0L))
x = unlist(grad_norm_features[grep("min|mean|max", names(grad_norm_features))])
expect_true(all(diff(x) >= 0L))
grad_scale_features = features[grep("grad_scale", names(features))]
x = unlist(grad_scale_features[grep("min|lq|med|uq|max", names(grad_scale_features))])
expect_true(all(diff(x) >= 0L))
x = unlist(grad_scale_features[grep("min|mean|max", names(grad_scale_features))])
expect_true(all(diff(x) >= 0L))
})
test_that("Show Error", {
feat.object = createFeatureObject(init = iris[, -5],
objective = "Sepal.Length")
expect_error(calculateFeatureSet(feat.object, "ela_curv"))
feat.object = createFeatureObject(init = iris[, -5],
objective = "Sepal.Length", fun = function(x) sum(x^2))
expect_error(calculateFeatureSet(feat.object, "ela_curv",
control = list(allow_costs = FALSE)))
})
|
getJenksBreaks <- function(var, k, subset = NULL) {
k <- k - 1;
if (k > length(unique(var))) {
k <- length(unique(var));
}
brks <- rep(1, k + 1);
if (!is.null(subset)) {
if (length(var) > subset) {
ind <- c(seq(from=1, to=length(var), by=floor(length(var)/subset)), length(var));
var <- var[ind];
}
}
d <- sort(var);
length_d <- length(d);
return(.C("jenksBrks", as.double(d), as.integer(k), as.integer(length_d), as.double(brks))[[4]]);
}
|
system <- function(command, intern = FALSE,
ignore.stdout = FALSE, ignore.stderr = FALSE,
wait = TRUE, input = NULL,
show.output.on.console = TRUE, minimized = FALSE,
invisible = TRUE)
{
if(!is.logical(intern) || is.na(intern))
stop("'intern' must be TRUE or FALSE")
if(!is.logical(ignore.stdout) || is.na(ignore.stdout))
stop("'ignore.stdout' must be TRUE or FALSE")
if(!is.logical(ignore.stderr) || is.na(ignore.stderr))
stop("'ignore.stderr' must be TRUE or FALSE")
if(!is.logical(wait) || is.na(wait))
stop("'wait' must be TRUE or FALSE")
if(!is.logical(show.output.on.console) || is.na(show.output.on.console))
stop("'show.output.on.console' must be TRUE or FALSE")
if(!is.logical(minimized) || is.na(minimized))
stop("'minimized' must be TRUE or FALSE")
if(!is.logical(invisible) || is.na(invisible))
stop("'invisible' must be TRUE or FALSE")
stdout <- ifelse(ignore.stdout, FALSE, "")
stderr <- ifelse(ignore.stderr, FALSE, "")
f <- ""
if (!is.null(input)) {
f <- tempfile()
on.exit(unlink(f))
writeLines(input, f)
}
if (intern) {
flag <- 3L
if(stdout == "") stdout <- TRUE
if(!ignore.stderr && .Platform$GUI == "Rgui") stderr <- TRUE
} else {
flag <- if (wait) ifelse(show.output.on.console, 2L, 1L) else 0L
}
if (invisible) flag <- 20L + flag
else if (minimized) flag <- 10L + flag
.Internal(system(command, as.integer(flag), f, stdout, stderr))
}
system2 <- function(command, args = character(),
stdout = "", stderr = "", stdin = "", input = NULL,
env = character(),
wait = TRUE, minimized = FALSE, invisible = TRUE)
{
if(!is.logical(wait) || is.na(wait))
stop("'wait' must be TRUE or FALSE")
if(!is.logical(minimized) || is.na(minimized))
stop("'minimized' must be TRUE or FALSE")
if(!is.logical(invisible) || is.na(invisible))
stop("'invisible' must be TRUE or FALSE")
command <- paste(c(shQuote(command), env, args), collapse = " ")
if(is.null(stdout)) stdout <- FALSE
if(is.null(stderr)) stderr <- FALSE
if(length(stdout) != 1L) stop("'stdout' must be of length 1")
if(length(stderr) != 1L) stop("'stderr' must be of length 1")
if (!is.null(input)) {
f <- tempfile()
on.exit(unlink(f))
writeLines(input, f)
} else f <- stdin
flag <- if (isTRUE(stdout) || isTRUE(stderr)) 3L
else if (wait) ifelse(identical(stdout, ""), 2L, 1L)
else 0L
if (invisible) flag <- 20L + flag
else if (minimized) flag <- 10L + flag
.Internal(system(command, flag, f, stdout, stderr))
}
shell <- function(cmd, shell, flag = "/c", intern = FALSE,
wait = TRUE, translate = FALSE, mustWork = FALSE, ...)
{
if(missing(shell)) {
shell <- Sys.getenv("R_SHELL")
if(!nzchar(shell)) shell <- Sys.getenv("COMSPEC")
}
if(missing(flag) &&
any(!is.na(pmatch(c("bash", "tcsh", "sh"), basename(shell)))))
flag <- "-c"
cmd0 <- cmd
if(translate) cmd <- chartr("/", "\\", cmd)
if(!is.null(shell)) cmd <- paste(shell, flag, cmd)
res <- system(cmd, intern = intern, wait = wait | intern,
show.output.on.console = wait, ...)
if(!intern && res && !is.na(mustWork))
if(mustWork)
if(res == -1L)
stop(gettextf("'%s' could not be run", cmd0), domain = NA)
else stop(gettextf("'%s' execution failed with error code %d",
cmd0, res), domain = NA)
else
if(res == -1L)
warning(gettextf("'%s' could not be run", cmd0), domain = NA)
else warning(gettextf("'%s' execution failed with error code %d",
cmd0, res), domain = NA)
if(intern) res else invisible(res)
}
shell.exec <- function(file) .Internal(shell.exec(file))
Sys.timezone <- function(location = TRUE)
{
tz <- Sys.getenv("TZ", names = FALSE)
if(nzchar(tz)) return(tz)
if(location) return(.Internal(tzone_name()))
z <- as.POSIXlt(Sys.time())
zz <- attr(z, "tzone")
if(length(zz) == 3L) zz[2L + z$isdst] else zz[1L]
}
Sys.which <- function(names) .Internal(Sys.which(as.character(names)))
|
mutUniformPruefer = makeMutator(
mutator = function(ind, p = 1 / length(ind)) {
n = length(ind)
nrs = 1:(n + 2L)
r = runif(n) < p
if (sum(r) > 0)
ind[r] = sample(nrs, sum(r), replace = TRUE)
return(ind)
},
supported = "custom")
oneEdgeExchange = function(edgelist, edge.id) {
the.edge.idx = edge.id
node1 = edgelist[1L, the.edge.idx]
node2 = edgelist[2L, the.edge.idx]
getRandom = function(set) {
if (length(set) == 1L)
return(set)
return(sample(set, 1L))
}
getReachableNodes = function(edgelist, node) {
nodes = node
nodes2 = nodes
while (length(nodes2) > 0L) {
the.node = nodes2[1L]
is.adjacent = apply(edgelist, 2L, function(x) any(x == the.node))
adjacent.nodes = unique(as.integer(edgelist[, is.adjacent]))
nodes2 = setdiff(c(nodes2, adjacent.nodes), the.node)
nodes = unique(c(nodes, adjacent.nodes))
edgelist = edgelist[, !is.adjacent, drop = FALSE]
}
return(nodes)
}
nodes1 = getReachableNodes(edgelist[, -the.edge.idx], node1)
nodes2 = getReachableNodes(edgelist[, -the.edge.idx], node2)
new.node1 = getRandom(nodes1)
new.node2 = getRandom(nodes2)
edgelist[, the.edge.idx] = c(new.node1, new.node2)
return(edgelist)
}
edgeExchange = function(edgelist, p = 1 / ncol(edgelist)) {
m = ncol(edgelist)
for (i in 1:m) {
if (runif(1L) < p) {
edgelist = oneEdgeExchange(edgelist, i)
}
}
return(edgelist)
}
mutEdgeExchange = makeMutator(
mutator = function(ind, p = 1 / ncol(ind)) {
edgeExchange(ind, p)
},
supported = "custom")
subgraphMST = function(edgelist, sigma, instance) {
m = ncol(edgelist)
n.objectives = instance$n.weights
nsel = sample(3:sigma, 1L)
start = sample(1:m, 1L)
sel.edges = start
sel.nodes = edgelist[, start]
inds = 1:m
while (length(sel.nodes) < nsel) {
rr = apply(edgelist, 2L, function(x) any(x %in% sel.nodes))
rr = setdiff(which(rr), sel.edges)
sel.edges = sort(c(sel.edges, rr))
sel.nodes = unique(as.integer(edgelist[, sel.edges]))
}
sel.nodes = sort(sel.nodes)
obj.idx = sample(1:n.objectives, 1L)
dd = instance$weights[[obj.idx]][sel.nodes, sel.nodes]
mstres = vegan::spantree(d = dd)
repl.edges = matrix(
c(sel.nodes[2:(length(sel.edges) + 1L)],
sel.nodes[mstres$kid]), byrow = TRUE, nrow = 2L)
edgelist[, sel.edges] = repl.edges
return(edgelist)
}
mutSubgraphMST = makeMutator(
mutator = function(ind, sigma = floor(ncol(ind) / 2), instance = NULL) {
subgraphMST(ind, sigma, instance)
},
supported = "custom"
)
|
print.summary.robmixglm <- function(x, digits = max(3L, getOption("digits") - 3L), ...) {
if (!inherits(x, "summary.robmixglm"))
stop("Use only with 'summary.robmixglm' objects.\n")
printCoefmat(x$coefficients,digits=digits,na.print="")
cat("\n")
print(data.frame(logLik = x$logLik,AIC = x$AIC, BIC = x$BIC,
row.names = " "))
invisible(x)
}
|
"strategies.RPS"
|
distrARITH <- function(library = NULL)
{
infoShow(pkg = "distr", filename = "ARITHMETICS", library = library)
}
distrMASK <- function(library = NULL)
{
infoShow(pkg = "distr", filename="MASKING", library = library)
}
|
transformPlanarCalibrationCoordinates <- function(tpar, nx, ny, sx, sy=NULL){
if(is.null(sy)) sy <- sx
tpar <- matrix(tpar, ncol=6, byrow=TRUE)
grid <- cbind(rep(0:(nx-1), ny)*sx, c(matrix(t(matrix((ny-1):0, nrow=ny, ncol=nx)), nrow=1, byrow=F))*sy, rep(0, nx*ny))
grid <- grid - matrix(colMeans(grid), nrow=nrow(grid), ncol=3, byrow=TRUE)
coor.3d <- matrix(NA, nrow=nrow(tpar)*nrow(grid), ncol=3)
for(i in 1:nrow(tpar)){
grid_transform <- grid %*% rotationMatrixZYX_SM(t=c(tpar[i, 1:3]))
coor.3d[((i-1)*nrow(grid)+1):(i*nrow(grid)), ] <- grid_transform + matrix(tpar[i, 4:6], nrow=nrow(grid_transform), ncol=3, byrow=TRUE)
}
coor.3d
}
|
DAISIE_SR_loglik_all_choosepar <- function(
trparsopt,
trparsfix,
idparsopt,
idparsfix,
idparsnoshift,
pars2,
datalist,
methode,
CS_version,
abstolint = 1E-16,
reltolint = 1E-10
) {
trpars1 <- rep(0, 11)
trpars1[idparsopt] <- trparsopt
if (length(idparsfix) != 0) {
trpars1[idparsfix] <- trparsfix
}
if (length(idparsnoshift) != 0) {
trpars1[idparsnoshift] <- trpars1[idparsnoshift - 5]
}
if (max(trpars1) > 1 | min(trpars1) < 0) {
loglik <- -Inf
} else {
pars1 <- trpars1 / (1 - trpars1)
if (min(pars1) < 0) {
loglik <- -Inf
} else {
loglik <- DAISIE_SR_loglik_CS(
pars1 = pars1,
pars2 = pars2,
datalist = datalist,
methode = methode,
CS_version = CS_version,
abstolint = abstolint,
reltolint = reltolint,
verbose = FALSE
)
}
if (is.nan(loglik) || is.na(loglik)) {
cat("There are parameter values used which cause numerical problems.\n")
loglik <- -Inf
}
}
return(loglik)
}
DAISIE_SR_ML_CS <- DAISIE_SR_ML <- function(
datalist,
initparsopt,
idparsopt,
parsfix,
idparsfix,
idparsnoshift = 6:10,
res = 100,
ddmodel = 0,
cond = 0,
island_ontogeny = NA,
tol = c(1E-4, 1E-5, 1E-7),
maxiter = 1000 * round((1.25) ^ length(idparsopt)),
methode = "lsodes",
optimmethod = "subplex",
CS_version = 1,
verbose = 0,
tolint = c(1E-16, 1E-10),
jitter = 0) {
options(warn = -1)
out2err <- data.frame(lambda_c = NA, mu = NA, K = NA, gamma = NA, lambda_a2 = NA, lambda_c2 = NA, mu2 = NA, K2 = NA, gamma2 = NA, lambda_a2 = NA, tshift = NA, loglik = NA, df = NA, conv = NA)
out2err <- invisible(out2err)
idpars <- sort(c(idparsopt, idparsfix, idparsnoshift))
missnumspec <- unlist(lapply(datalist, function(list) {
list$missing_species
}))
if (CS_version != 1) {
cat("This version of CS is not yet implemented\n")
return(out2err)
}
if (sum(missnumspec) > (res - 1)) {
cat("The number of missing species is too large relative to the resolution of the ODE.\n")
return(out2err)
}
if ((prod(idpars == (1:11)) != 1) || (length(initparsopt) != length(idparsopt)) || (length(parsfix) != length(idparsfix))) {
cat("The parameters to be optimized and/or fixed are incoherent.\n")
return(out2err)
}
if (length(idparsopt) > 11) {
cat("The number of parameters to be optimized is too high.\n")
return(out2err)
}
namepars <- c("lambda_c", "mu", "K", "gamma", "lambda_a", "lambda_c2", "mu2", "K2", "gamma2", "lambda_a2", "tshift")
if (length(namepars[idparsopt]) == 0) {
optstr <- "nothing"
} else {
optstr <- namepars[idparsopt]
}
cat("You are optimizing", optstr, "\n")
if (length(namepars[idparsfix]) == 0) {
fixstr <- "nothing"
} else {
fixstr <- namepars[idparsfix]
}
cat("You are fixing", fixstr, "\n")
if (sum(idparsnoshift == (6:10)) != 5) {
noshiftstring <- namepars[idparsnoshift]
cat("You are not shifting", noshiftstring, "\n")
}
cat("Calculating the likelihood for the initial parameters.", "\n")
utils::flush.console()
trparsopt <- initparsopt / (1 + initparsopt)
trparsopt[which(initparsopt == Inf)] <- 1
trparsfix <- parsfix / (1 + parsfix)
trparsfix[which(parsfix == Inf)] <- 1
pars2 <- c(res, ddmodel, cond, verbose, island_ontogeny, tol, maxiter)
optimpars <- c(tol, maxiter)
initloglik <- DAISIE_SR_loglik_all_choosepar(trparsopt = trparsopt, trparsfix = trparsfix, idparsopt = idparsopt, idparsfix = idparsfix, idparsnoshift = idparsnoshift, pars2 = pars2, datalist = datalist, methode = methode, CS_version = CS_version, abstolint = tolint[1], reltolint = tolint[2])
cat("The loglikelihood for the initial parameter values is", initloglik, "\n")
if (initloglik == -Inf) {
cat("The initial parameter values have a likelihood that is equal to 0 or below machine precision. Try again with different initial values.\n")
return(out2err)
}
cat("Optimizing the likelihood - this may take a while.", "\n")
utils::flush.console()
out <-
DDD::optimizer(
optimmethod = optimmethod,
optimpars = optimpars,
fun = DAISIE_SR_loglik_all_choosepar,
trparsopt = trparsopt,
idparsopt = idparsopt,
trparsfix = trparsfix,
idparsfix = idparsfix,
idparsnoshift = idparsnoshift,
pars2 = pars2,
datalist = datalist,
methode = methode,
CS_version = CS_version,
abstolint = tolint[1],
reltolint = tolint[2],
jitter = jitter
)
if (out$conv != 0) {
cat("Optimization has not converged. Try again with different initial values.\n")
out2 <- out2err
out2$conv <- out$conv
return(out2)
}
MLtrpars <- as.numeric(unlist(out$par))
MLpars <- MLtrpars / (1 - MLtrpars)
ML <- as.numeric(unlist(out$fvalues))
MLpars1 <- rep(0, 11)
MLpars1[idparsopt] <- MLpars
if (length(idparsfix) != 0) {
MLpars1[idparsfix] <- parsfix
}
if (MLpars1[3] > 10 ^ 7) {
MLpars1[3] <- Inf
}
if (length(idparsnoshift) != 0) {
MLpars1[idparsnoshift] <- MLpars1[idparsnoshift - 5]
}
if (MLpars1[8] > 10 ^ 7) {
MLpars1[8] <- Inf
}
out2 <- data.frame(lambda_c = MLpars1[1], mu = MLpars1[2], K = MLpars1[3], gamma = MLpars1[4], lambda_a = MLpars1[5], lambda_c2 = MLpars1[6], mu2 = MLpars1[7], K2 = MLpars1[8], gamma2 = MLpars1[9], lambda_a2 = MLpars1[10], tshift = MLpars1[11], loglik = ML, df = length(initparsopt), conv = unlist(out$conv))
s1 <- sprintf("Maximum likelihood parameter estimates: lambda_c: %f, mu: %f, K: %f, gamma: %f, lambda_a: %f, lambda_c2: %f, mu2: %f, K2: %f, gamma2: %f, lambda_a2: %f, time of shift: %f", MLpars1[1], MLpars1[2], MLpars1[3], MLpars1[4], MLpars1[5], MLpars1[6], MLpars1[7], MLpars1[8], MLpars1[9], MLpars1[10], MLpars1[11])
s2 <- sprintf("Maximum loglikelihood: %f", ML)
cat("\n", s1, "\n", s2, "\n")
return(invisible(out2))
}
|
Sub.S <-
function(z, t, Mat, j){
index <- which(Mat[,j] == 1 & rowSums(Mat[, -j]) == 0)
Sj <- sum(z[index])
names(Sj) <- paste("S", j, sep="")
return(Sj)
}
|
options(digits = 5)
c(nrd0 = bw.nrd0(precip), nrd = bw.nrd(precip),
ucv = bw.ucv(precip), bcv = bw.bcv(precip),
"SJ-dpi" = bw.SJ(precip, method = "dpi"),
"SJ-ste" = bw.SJ(precip, method = "ste"))
set.seed(1); bw.bcv(rnorm(6000))
set.seed(1); x <- rnorm(47000)
bw.ucv(x); bw.SJ(x, method = "dpi"); bw.SJ(x, method = "ste")
set.seed(1); bw.SJ(c(runif(65537), 1e7))
|
drks_de_version <- function(drksid, versionno) {
versionno <- versionno * 2
out <- tryCatch({
if (versionno != 0) {
version_query <- list(
TRIAL_ID = drksid,
version1 = paste0(
drksid,
"_",
versionno,
"_en.html"
),
version2 = paste0(
drksid,
"_",
versionno,
"_en.html"
)
)
} else {
version_query <- list(
TRIAL_ID = drksid,
version1 = paste0(
drksid,
"_en.html"
),
version2 = paste0(
drksid,
"_en.html"
)
)
}
res <- httr::POST(
"https://drks.de/drks_web/compareTrialVersions.do",
body = version_query,
encode = "form"
)
version <- rvest::read_html(res)
closeAllConnections()
rstatus <- NA
rstatus <- version %>%
rvest::html_nodes("li.state") %>%
rvest::html_text()
rstatus <- substr(rstatus, 23, nchar(rstatus))
enrolno <- NA
enrolno <- version %>%
rvest::html_nodes("li.targetSize") %>%
rvest::html_text() %>%
stringr::str_extract("[0-9]+")
enroltype <- NA
enroltype <- version %>%
rvest::html_nodes("li.running") %>%
rvest::html_text()
enroltype <- substr(enroltype, 19, nchar(enroltype))
startdate <- NA
startdate <- version %>%
rvest::html_nodes("li.schedule") %>%
rvest::html_text() %>%
stringr::str_extract("[0-9]{4}/[0-9]{2}/[0-9]{2}") %>%
as.Date(format = "%Y/%m/%d") %>%
format("%Y-%m-%d")
closingdate <- NA
closingdate <- version %>%
rvest::html_nodes("li.deadline") %>%
rvest::html_text() %>%
stringr::str_extract("[0-9]{4}/[0-9]{2}/[0-9]{2}") %>%
as.Date(format = "%Y/%m/%d") %>%
format("%Y-%m-%d")
primaryoutcomes <- NA
primaryoutcomes <- version %>%
rvest::html_nodes("p.primaryEndpoint") %>%
rvest::html_text2() %>%
jsonlite::toJSON()
secondaryoutcomes <- NA
secondaryoutcomes <- version %>%
rvest::html_nodes("p.secondaryEndpoints") %>%
rvest::html_text2() %>%
jsonlite::toJSON()
min_age <- NA
min_age <- version %>%
rvest::html_node("li.minAge") %>%
rvest::html_text2() %>%
gsub(pattern = "Minimum Age:", replacement = "", .data) %>%
trimws()
max_age <- NA
max_age <- version %>%
rvest::html_node("li.maxAge") %>%
rvest::html_text2() %>%
gsub(pattern = "Maximum Age:", replacement = "", .data) %>%
trimws()
gender <- NA
gender <- version %>%
rvest::html_node("li.gender") %>%
rvest::html_text2() %>%
gsub(pattern = "Gender:", replacement = "", .data) %>%
trimws()
inclusion_criteria <- NA
inclusion_criteria <- version %>%
rvest::html_nodes(".inclusionAdd") %>%
rvest::html_text2() %>%
jsonlite::toJSON()
exclusion_criteria <- NA
exclusion_criteria <- version %>%
rvest::html_nodes(".exclusion") %>%
rvest::html_text2() %>%
jsonlite::toJSON()
contacts <- tibble::tribble(
~label, ~affiliation, ~telephone, ~fax, ~email, ~url
)
addresses <- version %>%
rvest::html_nodes("ul.addresses li.address")
for (address in addresses) {
label <- NA
label <- address %>%
rvest::html_nodes(xpath = "label") %>%
rvest::html_text2()
affiliation <- NA
affiliation <- address %>%
rvest::html_nodes("li.address-affiliation") %>%
rvest::html_text2() %>%
paste(collapse = " ") %>%
trimws()
address_name <- NA
address_name <- address %>%
rvest::html_nodes("li.address-name") %>%
rvest::html_text2() %>%
paste(collapse = " ") %>%
trimws()
telephone <- NA
telephone <- address %>%
rvest::html_nodes(
xpath = paste(
selectr::css_to_xpath(".address-telephone"),
"/node()[not(self::label)]"
)
) %>%
rvest::html_text2() %>%
paste(collapse = " ") %>%
trimws()
fax <- NA
fax <- address %>%
rvest::html_nodes(
xpath = paste(
selectr::css_to_xpath(".address-fax"),
"/node()[not(self::label)]"
)
) %>%
rvest::html_text2() %>%
paste(collapse = " ") %>%
trimws()
email <- NA
email <- address %>%
rvest::html_nodes(
xpath = paste(
selectr::css_to_xpath(".address-email"),
"/node()[not(self::label)]"
)
) %>%
rvest::html_text2() %>%
paste(collapse = " ") %>%
trimws()
url <- NA
url <- address %>%
rvest::html_nodes(
xpath = paste(
selectr::css_to_xpath(".address-url"),
"/node()[not(self::label)]"
)
) %>%
rvest::html_text2() %>%
paste(collapse = " ") %>%
trimws()
contacts <- contacts %>%
dplyr::bind_rows(
tibble::tribble(
~label,
~affiliation,
~name,
~telephone,
~fax,
~email,
~url,
label,
affiliation,
address_name,
telephone,
fax,
email,
url
)
)
}
contacts <- contacts %>%
jsonlite::toJSON()
data <- c(
rstatus,
startdate,
closingdate,
enrolno,
enroltype,
min_age,
max_age,
gender,
inclusion_criteria,
exclusion_criteria,
primaryoutcomes,
secondaryoutcomes,
contacts
)
return(data)
},
error = function(cond) {
message(paste(
"Version caused an error:",
drksid, "version", versionno
))
message("Here's the original error message:")
message(paste(cond, "\n"))
return("Error")
},
warning = function(cond) {
message(paste(
"Version caused a warning:",
drksid, "version", versionno
))
message("Here's the original warning message:")
message(paste(cond, "\n"))
return("Warning")
},
finally = {
})
return(out)
}
|
setGeneric("reconstruct",
function(methMat,mBase,chunk.size=1e6,save.db=FALSE,...)
standardGeneric("reconstruct"))
setMethod("reconstruct",signature(mBase="methylBase"),
function(methMat,mBase,save.db=FALSE,...){
if(min(methMat)<0 | max(methMat)>100 ){
stop("make sure 'methMat' is percent methylation " ,
"matrix (values between 0-100)")
}
if(nrow(methMat) != nrow(mBase) | ncol(methMat) != length([email protected]) ){
stop("methMat dimensions do not match number of samples\n",
"and number of bases in methylBase object")
}
df=getData(mBase)
mat=df[,[email protected]]+getData(mBase)[,[email protected]]
numCs=round(methMat*mat/100)
numTs=round((100-methMat)*mat/100)
df[,[email protected]]=numCs
df[,[email protected]]=numTs
if(!save.db) {
new("methylBase",df,[email protected],
assembly=mBase@assembly,context=mBase@context,
treatment=mBase@treatment,[email protected],
[email protected],[email protected],
destranded=mBase@destranded,resolution=mBase@resolution )
} else {
args <- list(...)
if( !( "dbdir" %in% names(args)) ){
dbdir <- .check.dbdir(getwd())
} else { dbdir <- .check.dbdir(args$dbdir) }
if(!( "suffix" %in% names(args) ) ){
suffix <- "_reconstructed"
} else {
suffix <- paste0("_",args$suffix)
}
makeMethylBaseDB(df=df,dbpath=dbdir,dbtype="tabix",[email protected],
assembly=mBase@assembly,context=mBase@context,
treatment=mBase@treatment,[email protected],
[email protected],[email protected],
destranded=mBase@destranded, resolution=mBase@resolution,
suffix=suffix )
}
}
)
assocComp <- function(mBase,sampleAnnotation){
if(length(sampleAnnotation) < 1) {
stop("ERROR: Sample Annotation has to have at least one column.")
}
scale=TRUE
center=TRUE
mat=percMethylation(mBase)
pr=prcomp(mat,scale.=scale,center=center)
vars=100*pr$sdev**2/sum(pr$sdev**2)
res=list()
for(i in 1:ncol(sampleAnnotation)){
if(is.factor(sampleAnnotation[,i]) | is.character(sampleAnnotation[,i]) |
is.logical(sampleAnnotation[,i])){
annot=as.factor(sampleAnnotation[,i])
res[[names(sampleAnnotation)[i]]]=apply(pr$rotation,2,
function(x){
if(length(unique(annot))>2 ){
kruskal.test(split(x,annot) )$p.value
}else{
wilcox.test(split(x,annot)[[1]],
split(x,annot)[[2]] )$p.value
}
})
}else{
annot= sampleAnnotation[,i]
res[[names(sampleAnnotation)[i]]]=apply(pr$rotation,2,function(x){
cor.test(x,annot)$p.value
})
}
}
list(pcs=pr$rotation,vars=vars,association=do.call("rbind",res))
}
setGeneric("removeComp", function(mBase,comp = NULL ,chunk.size=1e6,save.db=FALSE,...)
standardGeneric("removeComp"))
setMethod("removeComp",signature(mBase="methylBase"),
function(mBase,comp,save.db,...){
if(anyNA(comp) || is.null(comp)){
stop("no component to remove\n")
}
if(any(comp > length([email protected]) )){
stop("'comp' elements can only take values between 1 and number of samples\n")
}
scale=TRUE
center=TRUE
mat=percMethylation(mBase)
mat=scale(mat,scale=scale,center=center)
centers <- attr(mat,'scaled:center')
scales <- attr(mat,'scaled:scale')
pr=prcomp(mat,scale.=FALSE,center=FALSE)
pr$rotation[,comp]=0
res=pr$x %*% t(pr$rotation)
res=(scale(res,center=(-centers/scales),scale=1/scales))
attr(res,"scaled:center")<-NULL
attr(res,"scaled:scale")<-NULL
res[res>100]=100
res[res<0]=0
reconstruct(res,mBase,save.db = save.db, ...=...)
}
)
|
test.data.table = function(script="tests.Rraw", verbose=FALSE, pkg=".", silent=FALSE, showProgress=interactive()&&!silent) {
stopifnot(isTRUEorFALSE(verbose), isTRUEorFALSE(silent), isTRUEorFALSE(showProgress))
if (exists("test.data.table", .GlobalEnv,inherits=FALSE)) {
if ("package:data.table" %chin% search()) stop("data.table package is loaded. Unload or start a fresh R session.")
rootdir = if (pkg!="." && pkg %chin% dir()) file.path(getwd(), pkg) else Sys.getenv("PROJ_PATH")
subdir = file.path("inst","tests")
} else {
rootdir = getNamespaceInfo("data.table","path")
subdir = "tests"
}
fulldir = file.path(rootdir, subdir)
stopifnot(is.character(script), length(script)==1L, !is.na(script), nzchar(script))
if (!grepl(".Rraw$", script))
stop("script must end with '.Rraw'. If a file ending '.Rraw.bz2' exists, that will be found and used.")
if (identical(script,"*.Rraw")) {
scripts = dir(fulldir, "*.Rraw.*")
scripts = scripts[!grepl("bench|other", scripts)]
scripts = gsub("[.]bz2$","",scripts)
return(sapply(scripts, function(fn) {
err = try(test.data.table(script=fn, verbose=verbose, pkg=pkg, silent=silent, showProgress=showProgress))
cat("\n");
identical(err, TRUE)
}))
}
if (!identical(basename(script), script)) {
subdir = dirname(script)
fulldir = normalizePath(subdir, mustWork=FALSE)
fn = basename(script)
} else {
fn = script
}
if (!file.exists(file.path(fulldir, fn))) {
fn2 = paste0(fn,".bz2")
if (!file.exists(file.path(fulldir, fn2)))
stop(gettextf("Neither %s nor %s exist in %s",fn, fn2, fulldir, domain="R-data.table"))
fn = fn2
}
fn = setNames(file.path(fulldir, fn), file.path(subdir, fn))
oldEnv = Sys.getenv(c("_R_CHECK_LENGTH_1_LOGIC2_", "TZ"), unset=NA_character_)
Sys.setenv("_R_CHECK_LENGTH_1_LOGIC2_" = TRUE)
oldRNG = suppressWarnings(RNGversion("3.5.0"))
if (is.null(options()$warnPartialMatchArgs)) options(warnPartialMatchArgs=FALSE)
if (is.null(options()$warnPartialMatchAttr)) options(warnPartialMatchAttr=FALSE)
if (is.null(options()$warnPartialMatchDollar)) options(warnPartialMatchDollar=FALSE)
oldOptions = options(
datatable.verbose = verbose,
encoding = "UTF-8",
scipen = 0L,
datatable.optimize = Inf,
datatable.alloccol = 1024L,
datatable.print.class = FALSE,
datatable.print.trunc.cols = FALSE,
datatable.rbindlist.check = NULL,
datatable.integer64 = "integer64",
warnPartialMatchArgs = base::getRversion()>="3.6.0",
warnPartialMatchAttr = TRUE,
warnPartialMatchDollar = TRUE,
width = max(getOption('width'), 80L),
datatable.old.fread.datetime.character = FALSE
)
cat("getDTthreads(verbose=TRUE):\n")
getDTthreads(verbose=TRUE)
cat("test.data.table() running:", fn, "\n")
env = new.env(parent=.GlobalEnv)
assign("testDir", function(x) file.path(fulldir, x), envir=env)
txt = eval(parse(text="tryCatch(mean(not__exist__), error = function(e) e$message)"), envir=.GlobalEnv)
foreign = txt != "object 'not__exist__' not found"
if (foreign) {
cat("\n**** This R session's language is not English. Each test will still check that the correct number of errors and/or\n",
"**** warnings are produced. However, to test the text of each error/warning too, please restart R with LANGUAGE=en\n\n", sep="")
}
assign("foreign", foreign, envir=env)
assign("nfail", 0L, envir=env)
assign("ntest", 0L, envir=env)
assign("prevtest", -1L, envir=env)
assign("whichfail", NULL, envir=env)
assign("started.at", proc.time(), envir=env)
assign("lasttime", proc.time()[3L], envir=env)
assign("timings", data.table( ID = seq_len(9999L), time=0.0, nTest=0L ), envir=env)
assign("memtest", as.logical(Sys.getenv("TEST_DATA_TABLE_MEMTEST", "FALSE")), envir=env)
assign("filename", fn, envir=env)
assign("inittime", as.integer(Sys.time()), envir=env)
assign("showProgress", showProgress, envir=env)
err = try(sys.source(fn, envir=env), silent=silent)
options(oldOptions)
for (i in oldEnv) {
if (is.na(oldEnv[i]))
Sys.unsetenv(names(oldEnv)[i])
else
do.call("Sys.setenv", as.list(oldEnv[i]))
}
suppressWarnings(do.call("RNGkind",as.list(oldRNG)))
tz = Sys.getenv("TZ", unset=NA)
cat("\n", date(),
" endian==", .Platform$endian,
", sizeof(long double)==", .Machine$sizeof.longdouble,
", longdouble.digits==", .Machine$longdouble.digits,
", sizeof(pointer)==", .Machine$sizeof.pointer,
", TZ==", if (is.na(tz)) "unset" else paste0("'",tz,"'"),
", Sys.timezone()=='", suppressWarnings(Sys.timezone()), "'",
", Sys.getlocale()=='", Sys.getlocale(), "'",
", l10n_info()=='", paste0(names(l10n_info()), "=", l10n_info(), collapse="; "), "'",
", getDTthreads()=='", paste0(gsub("[ ][ ]+","==",gsub("^[ ]+","",capture.output(invisible(getDTthreads(verbose=TRUE))))), collapse="; "), "'",
", ", .Call(Cdt_zlib_version),
"\n", sep="")
if (inherits(err,"try-error")) {
if (silent) return(FALSE)
stop("Failed after test ", env$prevtest, " before the next test() call in ",fn)
}
nfail = env$nfail
ntest = env$ntest
if (nfail > 0L) {
if (nfail > 1L) {s1="s";s2="s: "} else {s1="";s2=" "}
stop(nfail," error",s1," out of ",ntest,". Search ",names(fn)," for test number",s2,paste(env$whichfail,collapse=", "),".")
}
timings = env$timings
DT = head(timings[-1L][order(-time)], 10L)
if ((x<-sum(timings[["nTest"]])) != ntest) {
warning("Timings count mismatch:",x,"vs",ntest)
}
cat("10 longest running tests took ", as.integer(tt<-DT[, sum(time)]), "s (", as.integer(100*tt/(ss<-timings[,sum(time)])), "% of ", as.integer(ss), "s)\n", sep="")
print(DT, class=FALSE)
cat("All ",ntest," tests (last ",env$prevtest,") in ",names(fn)," completed ok in ",timetaken(env$started.at),"\n",sep="")
invisible(nfail==0L)
}
compactprint = function(DT, topn=2L) {
tt = vapply_1c(DT,function(x)class(x)[1L])
tt[tt=="integer64"] = "i64"
tt = substring(tt, 1L, 3L)
makeString = function(x) paste(x, collapse = ",")
cn = paste0(" [Key=",makeString(key(DT)),
" Types=", makeString(substring(sapply(DT, typeof), 1L, 3L)),
" Classes=", makeString(tt), "]")
if (nrow(DT)) {
print(copy(DT)[,(cn):="",verbose=FALSE], topn=topn, class=FALSE)
} else {
print(DT, class=FALSE)
if (ncol(DT)) cat(cn,"\n")
}
invisible()
}
INT = function(...) { as.integer(c(...)) }
ps_mem = function() {
cmd = sprintf("ps -o rss %s | tail -1", Sys.getpid())
ans = tryCatch(as.numeric(system(cmd, intern=TRUE, ignore.stderr=TRUE)), warning=function(w) NA_real_, error=function(e) NA_real_)
stopifnot(length(ans)==1L)
c("PS_rss"=round(ans / 1024, 1L))
}
gc_mem = function() {
m = apply(gc()[, c(2L, 4L, 6L)], 2L, sum)
names(m) = c("GC_used", "GC_gc_trigger", "GC_max_used")
m
}
test = function(num,x,y=TRUE,error=NULL,warning=NULL,message=NULL,output=NULL,notOutput=NULL,ignore.warning=NULL) {
.test.data.table = exists("nfail", parent.frame())
numStr = sprintf("%.8g", num)
if (.test.data.table) {
prevtest = get("prevtest", parent.frame())
nfail = get("nfail", parent.frame())
whichfail = get("whichfail", parent.frame())
assign("ntest", get("ntest", parent.frame()) + 1L, parent.frame(), inherits=TRUE)
lasttime = get("lasttime", parent.frame())
timings = get("timings", parent.frame())
memtest = get("memtest", parent.frame())
inittime = get("inittime", parent.frame())
filename = get("filename", parent.frame())
foreign = get("foreign", parent.frame())
showProgress = get("showProgress", parent.frame())
time = nTest = NULL
on.exit( {
now = proc.time()[3L]
took = now-lasttime
assign("lasttime", now, parent.frame(), inherits=TRUE)
timings[ as.integer(num), `:=`(time=time+took, nTest=nTest+1L), verbose=FALSE ]
} )
if (showProgress)
cat("\rRunning test id", numStr, " ")
} else {
memtest = FALSE
filename = NA_character_
foreign = FALSE
showProgress = FALSE
}
if (!missing(error) && !missing(y))
stop("Test ",numStr," is invalid: when error= is provided it does not make sense to pass y as well")
string_match = function(x, y, ignore.case=FALSE) {
length(grep(x, y, fixed=TRUE)) ||
length(tryCatch(grep(x, y, ignore.case=ignore.case), error=function(e)NULL))
}
xsub = substitute(x)
ysub = substitute(y)
actual = list("warning"=NULL, "error"=NULL, "message"=NULL)
wHandler = function(w) {
actual$warning <<- c(actual$warning, conditionMessage(w))
invokeRestart("muffleWarning")
}
eHandler = function(e) {
actual$error <<- conditionMessage(e)
e
}
mHandler = function(m) {
actual$message <<- c(actual$message, conditionMessage(m))
m
}
if (memtest) {
timestamp = as.numeric(Sys.time())
}
if (is.null(output) && is.null(notOutput)) {
x = suppressMessages(withCallingHandlers(tryCatch(x, error=eHandler), warning=wHandler, message=mHandler))
} else {
out = capture.output(print(x <- suppressMessages(withCallingHandlers(tryCatch(x, error=eHandler), warning=wHandler, message=mHandler))))
}
if (memtest) {
mem = as.list(c(inittime=inittime, filename=basename(filename), timestamp=timestamp, test=num, ps_mem(), gc_mem()))
fwrite(mem, "memtest.csv", append=TRUE, verbose=FALSE)
}
fail = FALSE
if (.test.data.table) {
if (num<prevtest+0.0000005) {
cat("Test id", numStr, "is not in increasing order\n")
fail = TRUE
}
assign("prevtest", num, parent.frame(), inherits=TRUE)
}
if (!fail) for (type in c("warning","error","message")) {
observed = actual[[type]]
expected = get(type)
if (type=="warning" && length(observed) && !is.null(ignore.warning)) {
stopifnot(length(ignore.warning)==1L, is.character(ignore.warning), !is.na(ignore.warning), nchar(ignore.warning)>=1L)
observed = grep(ignore.warning, observed, value=TRUE, invert=TRUE)
}
if (length(expected) != length(observed)) {
cat("Test ",numStr," produced ",length(observed)," ",type,"s but expected ",length(expected),"\n",sep="")
cat(paste("Expected:",expected), sep="\n")
cat(paste("Observed:",observed), sep="\n")
fail = TRUE
} else {
for (i in seq_along(expected)) {
if (!foreign && !string_match(expected[i], observed[i])) {
cat("Test",numStr,"didn't produce the correct",type,":\n")
cat("Expected:", expected[i], "\n")
cat("Observed:", observed[i], "\n")
fail = TRUE
}
}
}
}
if (fail && exists("out",inherits=FALSE)) {
cat("Output captured before unexpected warning/error/message:\n")
cat(out,sep="\n")
}
if (!fail && !length(error) && (length(output) || length(notOutput))) {
if (out[length(out)] == "NULL") out = out[-length(out)]
out = paste(out, collapse="\n")
output = paste(output, collapse="\n")
if (length(output) && !string_match(output, out)) {
cat("Test",numStr,"did not produce correct output:\n")
cat("Expected: <<",gsub("\n","\\\\n",output),">>\n",sep="")
cat("Observed: <<",gsub("\n","\\\\n",out),">>\n",sep="")
fail = TRUE
}
if (length(notOutput) && string_match(notOutput, out, ignore.case=TRUE)) {
cat("Test",numStr,"produced output but should not have:\n")
cat("Expected absent (case insensitive): <<",gsub("\n","\\\\n",notOutput),">>\n",sep="")
cat("Observed: <<",gsub("\n","\\\\n",out),">>\n",sep="")
fail = TRUE
}
}
if (!fail && !length(error) && (!length(output) || !missing(y))) {
y = try(y,TRUE)
if (identical(x,y)) return(invisible(TRUE))
all.equal.result = TRUE
if (is.data.table(x) && is.data.table(y)) {
if (!selfrefok(x) || !selfrefok(y)) {
cat("Test ",numStr," ran without errors but selfrefok(", if(!selfrefok(x))"x"else"y", ") is FALSE\n", sep="")
fail = TRUE
} else {
xc=copy(x)
yc=copy(y)
if (length(x)) for (i in which(vapply_1b(x,is.factor))) {.xi=x[[i]];xc[,(i):=factor(.xi)]}
if (length(y)) for (i in which(vapply_1b(y,is.factor))) {.yi=y[[i]];yc[,(i):=factor(.yi)]}
setattr(xc,"row.names",NULL)
setattr(yc,"row.names",NULL)
setattr(xc,"index",NULL)
setattr(yc,"index",NULL)
if (identical(xc,yc) && identical(key(x),key(y))) return(invisible(TRUE))
if (isTRUE(all.equal.result<-all.equal(xc,yc,check.environment=FALSE)) && identical(key(x),key(y)) &&
identical(vapply_1c(xc,typeof), vapply_1c(yc,typeof))) return(invisible(TRUE))
}
}
if (is.atomic(x) && is.atomic(y) && isTRUE(all.equal.result<-all.equal(x,y,check.names=!isTRUE(y))) && typeof(x)==typeof(y)) return(invisible(TRUE))
if (!fail) {
cat("Test", numStr, "ran without errors but failed check that x equals y:\n")
failPrint = function(x, xsub) {
cat(">", substitute(x), "=", xsub, "\n")
if (is.data.table(x)) compactprint(x) else {
nn = length(x)
cat(sprintf("First %d of %d (type '%s'): \n", min(nn, 6L), length(x), typeof(x)))
if (length(d <- dim(x))) do.call(`[`, c(list(x, drop = FALSE), lapply(pmin(d, 6L), seq_len)))
else print(head(x))
}
}
failPrint(x, deparse(xsub))
failPrint(y, deparse(ysub))
if (!isTRUE(all.equal.result)) cat(all.equal.result, sep="\n")
fail = TRUE
}
}
if (fail && .test.data.table) {
assign("nfail", nfail+1L, parent.frame(), inherits=TRUE)
assign("whichfail", c(whichfail, numStr), parent.frame(), inherits=TRUE)
}
invisible(!fail)
}
|
integerCols <- function(data) {
is.wholenumber <- function(x, tol = .Machine$double.eps ^ 0.5) {
abs(x - round(x)) < tol
}
all.cols <- 1:ncol(data)
integer.cols <- rep(0, ncol(data))
for (i in all.cols) {
x <- na.omit(data[ , i])
if(!is.numeric(x)) next
if(!all(is.finite(x))) next
if(min(is.wholenumber(x) == 1)) integer.cols[i] <- 1
}
multConvert(data, conversion = as.integer, cols = all.cols[integer.cols == 1])
}
|
ORSummaryFRRC <- function(dataset, FOMs, ANOVA, alpha, diffTRName) {
readerID <- dataset$descriptions$readerID
modalityID <- dataset$descriptions$modalityID
I <- length(modalityID)
J <- length(readerID)
K <- dim(dataset$ratings$NL)[3]
foms <- FOMs$foms
trtMeanDiffs <- FOMs$trtMeanDiffs
FRRC <- list()
if (I > 1) {
if (J > 1) {
msDen <- ANOVA$VarCom["Var","Estimates"] - ANOVA$VarCom["Cov1","Estimates"] +
(J - 1) * max(ANOVA$VarCom["Cov2","Estimates"] - ANOVA$VarCom["Cov3","Estimates"] ,0)
}
else msDen <- ANOVA$VarCom["Var","Estimates"] - ANOVA$VarCom["Cov1","Estimates"]
chisqVal <- (I-1)*ANOVA$TRanova["T","MS"]/msDen
p <- 1 - pchisq(chisqVal, I - 1)
FRRC$FTests <- data.frame(MS = c(ANOVA$TRanova["T", "MS"], msDen),
Chisq = c(chisqVal,NA),
DF = c(I - 1, NA),
p = c(p,NA),
row.names = c("Treatment", "Error"),
stringsAsFactors = FALSE)
stdErr <- sqrt(2 * msDen/J)
zStat <- vector()
PrGTz <- vector()
CI <- array(dim = c(choose(I,2),2))
for (i in 1:choose(I,2)) {
zStat[i] <- trtMeanDiffs[i,1]/stdErr
PrGTz[i] <- 2 * pnorm(abs(zStat[i]), lower.tail = FALSE)
CI[i, ] <- c(trtMeanDiffs[i,1] + qnorm(alpha/2) * stdErr,
trtMeanDiffs[i,1] + qnorm(1-alpha/2) * stdErr)
}
FRRC$ciDiffTrt <- data.frame(Estimate = trtMeanDiffs,
StdErr = rep(stdErr, choose(I, 2)),
z = zStat,
PrGTz = PrGTz,
CILower = CI[,1],
CIUpper = CI[,2],
row.names = diffTRName,
stringsAsFactors = FALSE)
}
stdErr <- vector()
df <- vector()
CI <- array(dim = c(I,2))
ci <- data.frame()
for (i in 1:I) {
df[i] <- K - 1
stdErr[i] <- sqrt((ANOVA$IndividualTrt[i,"varEachTrt"] +
(J-1)*max(ANOVA$IndividualTrt[i,"cov2EachTrt"],0))/J)
CI[i, ] <- c(FOMs$trtMeans[i,1] + qnorm(alpha/2) * stdErr[i],
FOMs$trtMeans[i,1] + qnorm(1-alpha/2) * stdErr[i])
rowName <- paste0("trt", modalityID[i])
ci <- rbind(ci, data.frame(Estimate = FOMs$trtMeans[i,1],
StdErr = stdErr[i],
DF = df[i],
CILower = CI[i,1],
CIUpper = CI[i,2],
row.names = rowName,
stringsAsFactors = FALSE))
}
FRRC$ciAvgRdrEachTrt <- ci
if (I > 1) {
trtMeanDiffs <- array(dim = c(J, choose(I, 2)))
Reader <- array(dim = c(J, choose(I, 2)))
stdErr <- array(dim = c(J, choose(I, 2)))
zStat <- array(dim = c(J, choose(I, 2)))
trDiffNames <- array(dim = c(J, choose(I, 2)))
PrGTz <- array(dim = c(J, choose(I, 2)))
CIReader <- array(dim = c(J, choose(I, 2),2))
ci <- data.frame()
for (j in 1:J) {
Reader[j,] <- rep(readerID[j], choose(I, 2))
stdErr[j,] <- sqrt(2 * (ANOVA$IndividualRdr[j,"varEachRdr"] - ANOVA$IndividualRdr[j,"cov1EachRdr"]))
pair <- 1
for (i in 1:I) {
if (i == I) break
for (ip in (i + 1):I) {
trtMeanDiffs[j, pair] <- foms[i, j] - foms[ip, j]
trDiffNames[j,pair] <- diffTRName[pair]
zStat[j,pair] <- trtMeanDiffs[j,pair]/stdErr[j,pair]
PrGTz[j,pair] <- 2 * pnorm(abs(zStat[j,pair]), lower.tail = FALSE)
CIReader[j, pair,] <- c(trtMeanDiffs[j,pair] + qnorm(alpha/2) * stdErr[j,pair],
trtMeanDiffs[j,pair] + qnorm(1-alpha/2) * stdErr[j,pair])
rowName <- paste0("rdr", Reader[j,pair], "::", trDiffNames[j, pair])
ci <- rbind(ci, data.frame(Estimate = trtMeanDiffs[j, pair],
StdErr = stdErr[j,pair],
z = zStat[j, pair],
PrGTz = PrGTz[j, pair],
CILower = CIReader[j, pair,1],
CIUpper = CIReader[j, pair,2],
row.names = rowName,
stringsAsFactors = FALSE))
pair <- pair + 1
}
}
}
FRRC$ciDiffTrtEachRdr <- ci
FRRC$IndividualRdrVarCov1 <- ANOVA$IndividualRdr[,3:4]
}
return(FRRC)
}
|
if (compareVersion(paste0(version$major, ".", version$minor), "3.6") < 0) {
skip("Randomization algorithm has changed from R 3.6")
}
library(quanteda)
library(magrittr)
if (!"dplyr" %in% rownames(installed.packages())) {
skip("dplyr is not installed")
}
data(data_corpus_inaugural, package = "quanteda")
data_corpus_inaugural <- head(data_corpus_inaugural, n = 58)
data_tokens <- tokens(data_corpus_inaugural, remove_numbers = TRUE,
remove_punct = TRUE, remove_symbols = TRUE,
remove_separators = TRUE, remove_url = TRUE) %>%
tokens_tolower() %>%
tokens_remove(c(stopwords("english"),
"may", "shall", "can",
"must", "upon", "with", "without")) %>%
tokens_select(min_nchar = 3)
data_dfm <- dfm(data_tokens) %>%
dfm_trim(min_termfreq = 5, min_docfreq = 2)
keyATM_docs <- keyATM_read(data_dfm)
keywords <- list(Government = c("laws", "law", "executive"),
Congress = c("congress", "party"),
Peace = c("peace", "world", "freedom"),
Constitution = c("constitution", "rights"),
ForeignAffairs = c("foreign", "war"))
vars <- docvars(data_corpus_inaugural)
vars %>%
tibble::as_tibble() %>%
dplyr::mutate(Period = dplyr::case_when(Year <= 1899 ~ "18_19c",
TRUE ~ "20_21c")) %>%
dplyr::mutate(Party = dplyr::case_when(Party == "Democratic" ~ "Democratic",
Party == "Republican" ~ "Republican",
TRUE ~ "Other")) %>%
dplyr::select(Party, Period) -> vars_selected
vars_selected %>%
dplyr::mutate(Party = factor(Party,
levels = c("Other", "Republican", "Democratic")),
Period = factor(Period,
levels = c("18_19c", "20_21c"))) -> vars_selected
out <- keyATM(docs = keyATM_docs,
no_keyword_topics = 5,
keywords = keywords,
model = "covariates",
model_settings = list(covariates_data = vars_selected,
covariates_formula = ~ Party + Period,
standardize = "all", covariates_model = "DirMulti"),
options = list(seed = 250, iterations = 20),
keep = c("Z", "S")
)
test_that("Covariates info", {
expect_output(mat <- covariates_info(out))
expect_type(mat, "double")
})
test_that("Covariates get", {
mat <- covariates_get(out)
expect_type(mat, "double")
expect_equivalent(dim(mat), c(58L, 4L))
expect_equivalent(colnames(mat), c("(Intercept)", "PartyRepublican", "PartyDemocratic", "Period20_21c"))
})
test_that("Doc Topic", {
skip_on_cran()
strata_topic <- by_strata_DocTopic(out, by_var = "Period20_21c",
labels = c("18_19c", "20_21c"),
posterior_mean = TRUE)
p <- plot(strata_topic, var_name = "Period", show_topic = c(1,2,3,4))
expect_s3_class(p, "keyATM_fig")
skip_on_os("linux")
expect_equal(summary(strata_topic, method = "eti", point = "median")[[2]]$Point[1], 0.09026675, tolerance = 0.000001)
expect_equal(summary(strata_topic, method = "hdi", point = "median")[[2]]$Upper[2], 0.08066711, tolerance = 0.000001)
expect_equal(summary(strata_topic)[[2]]$Lower[3], 0.1319587, tolerance = 0.000001)
})
test_that("Topic Word", {
skip_on_os("linux") ; skip_on_cran()
strata_tw <- by_strata_TopicWord(out, keyATM_docs, by = as.vector(vars_selected$Party))
top <- top_words(strata_tw, n = 3)
expect_equivalent(top$Democratic[1, 3], "world [\U2713]")
expect_equivalent(top$Republican[1, 5], "war [\U2713]")
expect_equivalent(top$Republican[3, 7], "done")
})
|
library("testthat")
library("permute")
context("Testing shuffle()")
test_that("shuffle(n) returns seq_len(n) when not permuting", {
ctrl <- how(within = Within(type = "none"))
expect_that(shuffle(3, control = ctrl), is_identical_to(seq_len(3)))
expect_that(shuffle(1, control = ctrl), is_identical_to(1L))
})
test_that("shuffle() returns integers", {
ctrl <- how(within = Within(type = "none"))
expect_that(shuffle(4), is_a("integer"))
expect_that(shuffle(100), is_a("integer"))
expect_that(shuffle(1, control = ctrl), is_identical_to(1L))
expect_that(shuffle(3, control = ctrl), is_identical_to(c(1L, 2L, 3L)))
})
test_that("shuffle() works for non-contigous blocks of samples", {
Plot <- factor(rep(1:4, 5))
CTRL <- how(plots = Plots(strata = Plot, type = "free"),
within = Within(type = "none"))
n <- 20
suppressWarnings(RNGversion("3.5.0"))
set.seed(2)
result <- shuffle(n, CTRL)
out1 <- as.integer(c( 3, 2, 1, 4,
7, 6, 5, 8,
11,10, 9,12,
15,14,13,16,
19,18,17,20))
expect_that(result, is_identical_to(out1))
out2 <- factor(as.integer(rep(c(3,2,1,4), 5)), levels = 1:4)
expect_that(Plot[result], is_identical_to(out2))
})
test_that("shuffle can permute both plots and within in presence of blocks", {
control <- how(within = Within(type = "free"),
plots = Plots(strata = rep(gl(2,7),2), type = "free"),
blocks = gl(2, 14))
permSet <- shuffle(28, control = control)
expect_identical(length(permSet), 28L)
expect_is(permSet, "integer")
})
test_that("constant within plots works", {
fac <- gl(4, 5)
ctrl <- how(within = Within(type = "series", constant = TRUE),
plots = Plots(strata = fac, type = "none"))
perm <- shuffle(length(fac), control = ctrl)
expect_identical(length(perm), length(fac))
expect_identical(length(perm), 20L)
expect_is(perm, "integer")
ctrl <- how(within = Within(type = "free", constant = TRUE),
plots = Plots(strata = fac, type = "none"))
perm <- shuffle(length(fac), control = ctrl)
expect_identical(length(perm), length(fac))
expect_identical(length(perm), 20L)
expect_is(perm, "integer")
fac <- gl(4, 9)
ctrl <- how(within = Within(type = "grid", nrow = 3, ncol = 3, constant = TRUE),
plots = Plots(strata = fac, type = "none"))
perm <- shuffle(length(fac), control = ctrl)
expect_identical(length(perm), length(fac))
expect_identical(length(perm), 36L)
expect_is(perm, "integer")
})
test_that("shuffel works with objects passed to n", {
obj <- 1:4
p <- shuffle(obj)
expect_is(p, "integer")
expect_identical(length(p), 4L)
obj <- as.integer(1:4)
p <- shuffle(obj)
expect_is(p, "integer")
expect_identical(length(p), 4L)
obj <- as.factor(1:4)
p <- shuffle(obj)
expect_is(p, "integer")
expect_identical(length(p), 4L)
obj <- letters[1:4]
p <- shuffle(obj)
expect_is(p, "integer")
expect_identical(length(p), 4L)
obj <- matrix(1:16, ncol = 4, nrow = 4)
p <- shuffle(obj)
expect_is(p, "integer")
expect_identical(length(p), 4L)
obj <- data.frame(A = 1:4, B = letters[1:4])
p <- shuffle(obj)
expect_is(p, "integer")
expect_identical(length(p), 4L)
})
|
gecko <- function(port = 4567L, version = "latest", check = TRUE,
loglevel = c("info", "fatal", "error", "warn", "config",
"debug", "trace"), verbose = TRUE,
retcommand = FALSE, ...){
assert_that(is_integer(port))
assert_that(is_string(version))
assert_that(is_logical(verbose))
loglevel <- match.arg(loglevel)
geckocheck <- gecko_check(verbose, check = check)
geckoplat <- geckocheck[["platform"]]
geckoversion <- gecko_ver(geckoplat, version)
eopts <- list(...)
args <- c(Reduce(c, eopts[names(eopts) == "args"]))
args[["port"]] <- sprintf("--port=%s", port)
args[["log"]] <- sprintf("--log=%s", loglevel)
if(retcommand){
return(paste(c(geckoversion[["path"]], args), collapse = " "))
}
pfile <- pipe_files()
geckodrv <- spawn_tofile(geckoversion[["path"]],
args, pfile[["out"]], pfile[["err"]])
if(isFALSE(geckodrv$is_alive())){
err <- paste0(readLines(pfile[["err"]]), collapse = "\n")
stop("Geckodriver couldn't be started\n", err)
}
startlog <- generic_start_log(geckodrv,
outfile = pfile[["out"]],
errfile = pfile[["err"]])
if(length(startlog[["stderr"]]) >0){
if(any(grepl("Address already in use", startlog[["stderr"]]))){
geckodrv$kill()
stop("Gecko Driver signals port = ", port, " is already in use.")
}
}
log <- as.environment(startlog)
list(
process = geckodrv,
output = function(timeout = 0L){
infun_read(geckodrv, log, "stdout", timeout = timeout,
outfile = pfile[["out"]], errfile = pfile[["err"]])
},
error = function(timeout = 0L){
infun_read(geckodrv, log, "stderr", timeout = timeout,
outfile = pfile[["out"]], errfile = pfile[["err"]])
},
stop = function(){geckodrv$kill()},
log = function(){
infun_read(geckodrv, log, outfile = pfile[["out"]], errfile = pfile[["err"]])
as.list(log)
}
)
}
gecko_check <- function(verbose, check = TRUE){
geckoyml <- system.file("yaml", "geckodriver.yml", package = "wdman")
gyml <- yaml::yaml.load_file(geckoyml)
platvec <- c("predlfunction", "binman::predl_github_assets","platform")
gyml[[platvec]] <-
switch(Sys.info()["sysname"],
Linux = grep(os_arch("linux"), gyml[[platvec]], value = TRUE),
Windows = grep(os_arch("win"), gyml[[platvec]], value = TRUE),
Darwin = grep("mac", gyml[[platvec]], value = TRUE),
stop("Unknown OS")
)
tempyml <- tempfile(fileext = ".yml")
write(yaml::as.yaml(gyml), tempyml)
if(check){
if(verbose) message("checking geckodriver versions:")
process_yaml(tempyml, verbose)
}
geckoplat <- gyml[[platvec]]
list(yaml = gyml, platform = geckoplat)
}
gecko_ver <- function(platform, version){
geckover <- binman::list_versions("geckodriver")[[platform]]
geckover <- if(identical(version, "latest")){
as.character(max(semver::parse_version(geckover)))
}else{
mtch <- match(version, geckover)
if(is.na(mtch) || is.null(mtch)){
stop("version requested doesnt match versions available = ",
paste(geckover, collapse = ","))
}
geckover[mtch]
}
geckodir <- normalizePath(
file.path(app_dir("geckodriver"), platform, geckover)
)
geckopath <- list.files(geckodir,
pattern = "geckodriver($|.exe$)",
full.names = TRUE)
list(version = geckover, dir = geckodir, path = geckopath)
}
|
coef.fcrr <- function(object, ...)
object$coef
|
loci_to_genind <- function(x,
ploidy = 2,
na.alleles = c("NA")){
if(!inherits(x, "loci")){
stop("Input 'x' must be a 'loci' object.")
}
if(!all(x$population == x$population[order(x$population)])){
message("Individuals in 'x' were not ordered, they have
been ordered by populations and populations ordered in alphabetic
order for the convertion.")
x <- x[order(x$population), ]
}
data_genind <- pegas::loci2genind(x,
ploidy,
na.alleles)
return(data_genind)
}
|
"driverA"
"driverB"
"drivers"
"parameters"
"simulation"
"accumulationRate"
NULL
NULL
NULL
utils::globalVariables(c("Variable", "Value", "Time", "Species", "Suitability", "Driver.density.y", "Driver.weights", "Fecundity", "Age", "Biomass", "Reproductive.age", "ci.max", "ci.min", "Time", "Color", "error", "value", "..scaled..", "driver.A.weight", "maximum.biomass", "growthrate", "carrying.capacity", "fecundity", "pollen.control", "growth.rate"))
|
`plot.segratioMCMC` <-
function(x, ..., row.index=c(1:10),
var.index=c(1:6),
marker.index=c(1:8))
{
if (class(x) != "segratioMCMC")
stop("'x' must be of class 'segratioMCMC'")
T.index <- grep("T\\[",coda::varnames(x$mcmc.list))
T.print <- T.index[marker.index]
drop <- T.index
b.index <- grep("b\\[",coda::varnames(x$mcmc.list))
if (length(b.index>0)){
b.print <- b.index[marker.index]
drop <- c(T.index, b.index)
}
var <- c(1:dim(x$mcmc.list[[1]])[2])[-drop]
var.index <- var[var.index]
plot(x$mcmc.list [,c(var.index,T.print)], ... )
}
|
test_that("'utf8_encode' can encode an ASCII string", {
expect_equal(utf8_encode("hello"), "hello")
})
test_that("'utf8_encode' can encode NULL or an NA string", {
expect_equal(utf8_encode(NULL), NULL)
expect_equal(utf8_encode(NA_character_), NA_character_)
})
test_that("'utf8_encode' preserves attributes", {
x <- matrix(LETTERS, 2, 13)
x[1, 4] <- "\xa4"
Encoding(x) <- "latin1"
dimnames(x) <- list(c("foo", "bar"), as.character(1:13))
class(x) <- "my_class"
local_ctype("UTF-8")
expect_equal(utf8_encode(x), enc2utf8(x))
})
test_that("'utf8_encode' can encode basic Unicode", {
x <- "\u200b"
Encoding(x) <- "UTF-8"
local_ctype("UTF-8")
expect_equal(utf8_encode(x), x)
})
test_that("'utf8_encode' can encode extended Unicode", {
skip_on_os("windows")
x <- intToUtf8(0x0001f60d)
Encoding(x) <- "UTF-8"
local_ctype("UTF-8")
expect_equal(utf8_encode(x), x)
})
test_that("'utf8_encode' can handle ASCII escapes", {
x <- "\x01\a\b\f\n\r\t\v\x7f"
expect_equal(utf8_encode(x), "\\u0001\\a\\b\\f\\n\\r\\t\\v\\u007f")
})
test_that("'utf8_encode' can handle invalid UTF-8", {
x <- "\xfe"
Encoding(x) <- "bytes"
expect_equal(utf8_encode(x), "\\xfe")
})
test_that("'utf8_encode' can handle bytes", {
x <- "\x01\a\b\f\n\r\t\v\x7f\x80\xff"
Encoding(x) <- "bytes"
expect_equal(
utf8_encode(x),
"\\x01\\a\\b\\f\\n\\r\\t\\v\\x7f\\x80\\xff"
)
})
test_that("'utf8_encode' can handle latin-1", {
x <- "her \xa320"
Encoding(x) <- "latin1"
with_ctype("C", {
latin <- utf8_encode(x)
})
expect_equal(latin, "her \\u00a320")
local_ctype("UTF-8")
expect_equal(utf8_encode(x), "her \u00a320")
})
test_that("'utf8_encode' can handle bytes", {
x <- c("fa\u00E7ile", "fa\xE7ile", "fa\xC3\xA7ile")
Encoding(x) <- c("UTF-8", "UTF-8", "bytes")
local_ctype("UTF-8")
y <- c("fa\u00e7ile", "fa\\xe7ile", "fa\\xc3\\xa7ile")
Encoding(y) <- c("UTF-8", "UTF-8", "bytes")
expect_equal(utf8_encode(x), y)
})
test_that("'utf8_encode escapes controls in UTF-8 text", {
local_ctype("UTF-8")
x <- "\n\u2026"
Encoding(x) <- "UTF-8"
y <- "\\n\u2026"
Encoding(y) <- "UTF-8"
expect_equal(utf8_encode(x), y)
})
test_that("'utf8_encode' can quote", {
x <- c("abcde", "x", "123", "\"", "'")
expect_equal(utf8_encode(x, quote = FALSE), encodeString(x, quote = ""))
expect_equal(utf8_encode(x, quote = TRUE), encodeString(x, quote = '"'))
})
test_that("'utf8_encode' ignores justify if width = 0", {
x <- c("abcde", "x", "123", "\"", "'")
expect_equal(
utf8_encode(x, width = 0, justify = "none"),
encodeString(x, width = 0, justify = "none")
)
expect_equal(
utf8_encode(x, width = 0, justify = "left"),
encodeString(x, width = 0, justify = "left")
)
expect_equal(
utf8_encode(x, width = 0, justify = "centre"),
encodeString(x, width = 0, justify = "centre")
)
expect_equal(
utf8_encode(x, width = 0, justify = "right"),
encodeString(x, width = 0, justify = "right")
)
})
test_that("'utf8_encode' can justify", {
x <- c("abcde", "x", "123", "\"", "'")
expect_equal(
utf8_encode(x, width = NULL, justify = "none"),
encodeString(x, width = NULL, justify = "none")
)
expect_equal(
utf8_encode(x, width = NULL, justify = "left"),
encodeString(x, width = NULL, justify = "left")
)
expect_equal(
utf8_encode(x, width = NULL, justify = "centre"),
encodeString(x, width = NULL, justify = "centre")
)
expect_equal(
utf8_encode(x, width = NULL, justify = "right"),
encodeString(x, width = NULL, justify = "right")
)
})
test_that("'utf8_encode' can justify and quote", {
expect_equal(
utf8_encode(c("1", "10", "100"), width = NULL, quote = TRUE),
encodeString(c("1", "10", "100"), width = NULL, quote = '"')
)
})
|
test_that("has ok print method", {
partial <- partial_factor("x")
expect_known_output(
print(partial),
test_path("test-partial-factor-print-partial.txt")
)
both <- vec_ptype2(partial, factor("y"))
expect_known_output(
print(both),
test_path("test-partial-factor-print-both.txt")
)
empty <- partial_factor()
expect_known_output(
print(empty),
test_path("test-partial-factor-print-empty.txt")
)
learned <- vec_ptype2(empty, factor("y"))
expect_known_output(
print(learned),
test_path("test-partial-factor-print-learned.txt")
)
expect_equal(vec_ptype_abbr(partial), "prtl_fctr")
})
test_that("order of levels comes from data", {
pfctr <- partial_factor(c("y", "x"))
fctr <- factor(levels = c("x", "y"))
expect_equal(levels(vec_ptype_common(pfctr, fctr)), c("x", "y"))
expect_equal(levels(vec_ptype_common(fctr, pfctr)), c("x", "y"))
})
test_that("partial levels added to end if not in data", {
pfctr <- partial_factor("y")
fctr <- factor(levels = "x")
expect_equal(levels(vec_ptype_common(pfctr, fctr)), c("x", "y"))
expect_equal(levels(vec_ptype_common(fctr, pfctr)), c("x", "y"))
})
test_that("can assert partial factors based on level presence", {
pfctr <- partial_factor("y")
expect_true(vec_is(factor("y"), pfctr))
expect_false(vec_is(factor("x"), pfctr))
expect_true(vec_is(factor(c("x", "y")), pfctr))
pfctr <- partial_factor(c("y", "z"))
expect_false(vec_is(factor("y"), pfctr))
expect_true(vec_is(factor(c("y", "z")), pfctr))
expect_true(vec_is(factor(c("x", "y", "z")), pfctr))
})
|
expected <- eval(parse(text="c(\"Min. \", \"1st Qu.\", \"Median \", \"Mean \", \"3rd Qu.\", \"Max. \")"));
test(id=0, code={
argv <- eval(parse(text="list(c(\"Min.\", \"1st Qu.\", \"Median\", \"Mean\", \"3rd Qu.\", \"Max.\"), FALSE, NULL, 0L, NULL, 0L, TRUE, NA)"));
.Internal(`format`(argv[[1]], argv[[2]], argv[[3]], argv[[4]], argv[[5]], argv[[6]], argv[[7]], argv[[8]]));
}, o=expected);
|
find_peaks<-function (x, y = NULL, num_peaks = NULL, adjust = 2, plot = FALSE,
...)
{
x <- as.vector(x)
if (length(x) < 2) {
warning("At least 2 observations must be given in 'x' to find peaks.")
return(NA)
}
if (is.null(y)) {
dens <- density(x, adjust = adjust, ...)
}
else {
y <- as.vector(y)
if (length(x) != length(y)) {
stop("The lengths of 'x' and 'y' must be equal.")
}
dens <- list(x = x, y = y)
}
second_deriv <- diff(sign(diff(dens$y)))
which_maxima <- which(second_deriv == -2) + 1
which_maxima <- which_maxima[findInterval(dens$x[which_maxima],
range(x)) == 1]
which_maxima <- which_maxima[order(dens$y[which_maxima],
decreasing = TRUE)]
if (length(which_maxima) > 0) {
peaks <- dens$x[which_maxima]
if (is.null(num_peaks) || num_peaks > length(peaks)) {
num_peaks <- length(peaks)
}
peaks <- peaks[seq_len(num_peaks)]
}
else {
peaks <- NA
}
peaks <- data.frame(x = peaks, y = dens$y[which_maxima][seq_len(num_peaks)])
if (plot) {
plot(dens, main = paste("adjust =", adjust))
points(peaks, , col = "red")
}
return( peaks )
}
find_valleys<-function (x, y = NULL, num_valleys = NULL, adjust = 2, ...)
{
x <- as.vector(x)
if (length(x) < 2) {
warning("At least 2 observations must be given in 'x' to find valleys.")
return(NA)
}
if (is.null(y)) {
dens <- density(x, adjust = adjust, ...)
}
else {
y <- as.vector(y)
if (length(x) != length(y)) {
stop("The lengths of 'x' and 'y' must be equal.")
}
dens <- list(x = x, y = y)
}
second_deriv <- diff(sign(diff(dens$y)))
which_minima <- which(second_deriv == 2) + 1
which_minima <- which_minima[findInterval(dens$x[which_minima],
range(x)) == 1]
which_minima <- which_minima[order(dens$y[which_minima],
decreasing = FALSE)]
if (length(which_minima) > 0) {
valleys <- dens$x[which_minima]
if (is.null(num_valleys) || num_valleys > length(valleys)) {
num_valleys <- length(valleys)
}
valleys <- valleys[seq_len(num_valleys)]
}
else {
valleys <- NA
}
return( valleys )
}
between_interval<-function (x, interval)
{
x <- x[findInterval(x, interval) == 1]
if (length(x) == 0) {
x <- NA
}
return( x )
}
apply_by<-function(x,by_idx,fun,...){
res<-sapply(unique(by_idx),function(a){
apply(x[,by_idx==a],1,fun,...)}
)
return(res)
}
orderCutpoints <- function(midindex, cutpoints) {
decreasingIdx <- midindex:1
increasingIdx <- (midindex:length(cutpoints))
cutpointsMonotone <- c(cummin(cutpoints[decreasingIdx]),
cummax(cutpoints[increasingIdx])[-1])
stopifnot(length(cutpointsMonotone)==length(cutpoints))
cutpointsMonotone[c(decreasingIdx, increasingIdx[-1])]
}
thresholdSCRNACountMatrix <-function( data_all ,
conditions = NULL ,
cutbins = NULL ,
nbins = 10 ,
bin_by = "median",
qt = 0.975,
min_per_bin = 50 ,
absolute_min= 0.0 ,
data_log = TRUE,
adj = 1
)
{
log_base <- 2
maybelogged <- max(range(data_all))<30
if(!data_log){
if(maybelogged){
warning("Data may already be log transformed! Should you set `data_log=TRUE`?")
}
log_data <- log( data_all+ 1, base = log_base )
} else{
if(!maybelogged){
warning("Data may not have been log transformed! Should you set `data_log=FALSE`?")
}
log_data <- data_all
}
if( is.null( conditions ) ){
conditions <- rep( 1, dim( data_all )[2] )
} else {
conditions <- as.character( conditions )
}
comp_zero_idx <- rowSums( log_data> 0.0 ) == 0
data <- 2^log_data[!comp_zero_idx,]-1
log_data <- log_data[!comp_zero_idx,]
uni_cond <- unique( conditions )
arg <- match.arg( bin_by, c( "quantile", "proportion", "mean", "median","iqr" ) )
if( arg == "median" ){
cond_stat <- apply_by( log_data, conditions, function( x ) if( all( x <= 0.0 ) ){ 0 } else { median( x[x>0.0]) })
} else if( arg == "mean" ){
cond_stat <- apply_by( data, conditions, function( x ) if( all(x <= 0.0 ) ){ 0 } else { log( mean( x[x>0.0])+1, base = log_base) } )
} else if( arg == "proportion" ){
cond_stat <- apply_by( data > 0, conditions, mean )
} else if( arg == "quantile" ){
cond_stat <- apply_by( log_data, conditions, function(x) if( all( x <= 0.0 ) ){ 0 } else { quantile( x[x>0.0], qt ) } )
} else if( arg == "iqr" ){
cond_stat <- apply_by( log_data, conditions, function(x) if( all( x <= 0.0 ) ){ 0 } else { IQR( x[x>0.0]) } )
} else {
stop("choose bin_by from c('proportion', 'mean', 'median' )")
}
rprop <- range( unlist(cond_stat) )
if( is.null(cutbins) ){
rprop <- range( cond_stat )
cutbins <- exp( seq( log( rprop[1] + 1 ),log( rprop[2] + 1 ),length.out = nbins + 1 ) ) - 1
cutbins[1] <- min( cutbins[1], rprop[1] - 1e-10 )
cutbins[ length( cutbins ) ]<- max( cutbins[length( cutbins )], rprop[2] + 1e-10 )
} else{
if( !( min(cutbins)< min(cond_stat) & max(cutbins) > max(cond_stat) ) ){
stop("range of cutbins must include the range of the log expression")
}
}
cond_stat_bins <- cut( cond_stat, cutbins )
t_prop_bins <- table( cond_stat_bins )
cond_stat_bins_array <- array( cond_stat_bins, dim( cond_stat ) )
dimnames( cond_stat_bins_array ) <- dimnames( cond_stat )
while( any( t_prop_bins < min_per_bin ) ){
i <- which.min( t_prop_bins )
if( i == 1 & t_prop_bins[ i ] < min_per_bin ){
cutbins <- cutbins[-( i + 1 )]
} else if( i == length( t_prop_bins ) & t_prop_bins[i] < min_per_bin ){
cutbins <- cutbins[ -i ]
} else if( t_prop_bins[ i ] < min_per_bin ){
cutbins <- cutbins[ -ifelse( t_prop_bins[i-1] < t_prop_bins[ i + 1 ], i, ( i + 1 ) ) ]
}
cond_stat_bins <- cut( cond_stat, cutbins )
t_prop_bins <- table( cond_stat_bins )
}
cond_stat_bins_array<-array(cond_stat_bins, dim(cond_stat))
dimnames(cond_stat_bins_array)<-dimnames(cond_stat)
log_data_list <- vector("list", length(levels(cond_stat_bins)))
names(log_data_list) <- levels(cond_stat_bins)
for( i in levels(cond_stat_bins)){
log_data_list[[i]]<-NULL
for( j in uni_cond){
x<-unlist(log_data[cond_stat_bins_array[,j]==i,conditions==j])
log_data_list[[i]]<-c(log_data_list[[i]],x[x>0.0])
}
}
dens <- lapply( log_data_list, function( x ) { if(length(x)>2){ density( x, adjust = adj ) } else{ NULL } })
peaks <- lapply( dens, function( dd ) { if( is.null(dd) ){ data.frame( x=0, y=0 ) }else{ find_peaks( dd$x,dd$y, adjust = adj )}} )
valleys<- lapply( dens, function( dd ) { if( is.null(dd) ){ list(0)} else{find_valleys( dd$x,dd$y, adjust = adj ) } })
single_modes<-do.call(c,lapply(peaks,function(x)abs(diff(x[1:2,1]))))<1|(lapply(list(do.call(c,lapply(peaks,function(x)abs(diff(x[1:2,2]))))),function(x)(x-median(na.omit(x)))/mad(na.omit(x)))[[1]]>2)
singles <- ldply( lapply( peaks,nrow ),function( x ) x == 1 )[,2]
single_modes[singles] <- TRUE
cutpoints<-lapply( seq_along(peaks), function( j ){
valleys[[j]][which( findInterval( valleys[[j]], sort( peaks[[j]][1:2,1]) ) == 1 )]
})
cutpoints[single_modes]<-NA
cutpoints <- lapply( cutpoints, function(x) ifelse( length( x )==0, NA, max( x ) ) )
names(cutpoints)<- names( peaks )
if( all( is.na( ldply( cutpoints )[,2] ) ) ){
for( i in 1:length( cutpoints ) ){
cutpoints[[i]] <- 0.0
}
} else {
for(i in 1:length( cutpoints ) ){
if( is.na( cutpoints[[i]] ) ){
if( i != length( cutpoints ) ){
cutpoints[[i]]<-do.call(c,cutpoints)[min(which(!is.na(do.call(c,cutpoints))))]
}else{
cutpoints[[i]]<-do.call(c,cutpoints)[max(which(!is.na(do.call(c,cutpoints))))]
}
}
}
}
vals2 <- unlist(valleys[which(unlist(lapply(peaks,nrow))==2)])
if( length(vals2) > 0 ){
midindex <- which(names(peaks)==names(which.min(abs(vals2-quantile(vals2,c(0.75),na.rm=TRUE)))))
} else{
midindex <- length(cutpoints)
}
cutpoints <- orderCutpoints(midindex, cutpoints)
cutpoints <- pmax(cutpoints, absolute_min)
if(data_log){
data_threshold <- log_data
} else {
data_threshold <- data
}
for( j in uni_cond ){
for( i in levels(cond_stat_bins) ){
if(any(cond_stat_bins_array[,j]==i))
data_threshold[cond_stat_bins_array[,j]==i,conditions==j][log_data[cond_stat_bins_array[,j]==i,conditions==j]<cutpoints[i]]<-0
}
}
nms <- names( cutpoints )
cutpoints <- unlist( cutpoints )
names( cutpoints ) <- nms
print( cutpoints )
data_threshold_all <- data_all*0
data_threshold_all[!comp_zero_idx,] <- data_threshold
bin_all <- factor(cond_stat_bins_array)
dim(bin_all) <- dim(cond_stat_bins_array)
res_obj <- list( counts_threshold = data_threshold_all,
original_data = data_all,
cutpoint = cutpoints,
bin = bin_all,
conditions = conditions,
density = dens
,peaks = peaks, valleys= valleys)
class( res_obj )<- c( "list", "thresholdSCRNACountMatrix" )
return( res_obj )
}
plot.thresholdSCRNACountMatrix<-function(x, ask=FALSE, wait.time=0, type='bin', indices=NULL, ...)
{
type <- match.arg(type, c('bin', 'gene'), several.ok=TRUE)
op <- par(ask=ask)
par(mar=c(3,3,2,1), mgp=c(2,.7,0), tck=-.01)
if('bin' %in% type){
for(i in 1:length(x$density)){
if(!is.null(x$density[[i]])){
plot(x$density[[i]],main=names(x$cutpoint)[i], ...)
abline(v=x$cutpoint[i],col="red",lty=2)
Sys.sleep(wait.time)
}
}
}
if('gene' %in% type){
uni_cond <- unique(x$conditions)
num_cond <- as.numeric(as.factor(x$conditions))
if(is.null(indices)){
indices <- 10L
}
if(is.finite(indices) && length(indices)==1){
indices <- sample(ncol(x$original_data), indices)
}
if(any(indices < 1 | indices>ncol(x$original_data))) stop('`indices` must range between 1 and the number of columns of the count matrix.')
for(i in indices){
den <- density(x$original_data[,i])
plot(den, main=paste0('Index ', i, '(', colnames(x$original_data)[i], ')'), ...)
for(j in seq_along(uni_cond)){
abline(v=with(x, cutpoint[bin[i,j]]), col=j, lty=2)
with(x, rug(original_data[j==num_cond,i], col=j))
}
}
}
par(op)
}
summary.thresholdSCRNACountMatrix <- function(object, ...){
zeros <- lapply(object[c('original_data', 'counts_threshold')], function(o){
apply(o>0, 2, mean)
})
vars <- lapply(object[c('original_data', 'counts_threshold')], function(o){
o[o==0] <- NA
apply(o, 2, var, na.rm=TRUE)
})
shapiro <- lapply(object[c('original_data', 'counts_threshold')], function(o){
apply(o, 2, function(x){
})
})
out <- list(zeros=zeros, vars=vars, shapiro=shapiro)
class(out) <- c(class(out), 'summaryThresholdSCRNA')
out
}
if(getRversion() >= "2.15.1") globalVariables(c('L2', 'bin', 'cutpoint', 'original_data'))
print.summaryThresholdSCRNA <- function(x, ...){
class(x) <- class(x)[-length(class(x))]
m <- as.data.table(reshape2::melt(x, na.rm=TRUE))
m <- m[!is.na(value),]
setnames(m, 'L1', 'metric')
summ <- m[,list(stat=names(summary(value)), value=summary(value)),keyby=list(L2, metric)]
summ$stat <- factor(summ$stat, levels=c('Min.', '1st Qu.', 'Median', 'Mean', '3rd Qu.', 'Max.'))
dc <- dcast.data.table(summ, stat + L2 ~ metric)
setnames(dc, c('stat', 'L2', 'vars', 'zeros'), c('Quantile', 'Data', 'variance', 'prop. expressed'))
dcdf <- as.data.frame(dc)
print(dcdf, right=FALSE, row.names=FALSE)
invisible(dc)
}
|
initializeModelObject <- function(parameter, model = "ROC", with.phi = FALSE, fix.observation.noise = FALSE, rfp.count.column = 1) {
if(model == "ROC") {
c.model <- new(ROCModel, with.phi, fix.observation.noise)
} else if (model == "FONSE") {
c.model = new(FONSEModel,with.phi,fix.observation.noise)
} else if (model == "PA") {
c.model <- new(PAModel, rfp.count.column,with.phi,fix.observation.noise)
} else if (model == "PANSE") {
c.model <- new(PANSEModel, rfp.count.column,with.phi,fix.observation.noise)
} else {
stop("Unknown model.")
}
c.model$setParameter(parameter)
return(c.model)
}
|
CreateWeights <- function(formula,Gorder=3,dif=TRUE,facCons=FALSE,data,side,type.ind,fac.level,ord.fac,
indTwo=NULL, indThree=NULL){
D3function <- function(alevel,blevel,clevel,type="A",ordABC=c(FALSE,FALSE,FALSE)){
if(type=="A"){
D3 <- D3Afunction(alevel=alevel,blevel=blevel,clevel=clevel,ord=ordABC[1])
}else if(type=="B"){
D3 <- D3Bfunction(alevel=alevel,blevel=blevel,clevel=clevel,ord=ordABC[2])
}else if(type=="C"){
D3 <- D3Cfunction(alevel=alevel,blevel=blevel,clevel=clevel,ord=ordABC[3])
}
return(D3)
}
D3Afunction <- function(alevel,blevel,clevel,ord=FALSE){
D3a <- matrix(0,nrow=0,ncol=(alevel*blevel*clevel))
if(ord==FALSE){
for(i in 1:(alevel-1)){
for(j in (i+1):alevel){
base.v <- rep(0,alevel)
base.v[i] <- -1
base.v[j] <- 1
base.mat <- diag((blevel*clevel)) %x% t(base.v)
D3a <- rbind(D3a,base.mat)
}
}
}else if(ord==TRUE){
for(i in 1:(alevel-1)){
base.v <- rep(0,alevel)
base.v[i] <- -1
base.v[(i+1)] <- 1
base.mat <- diag((blevel*clevel)) %x% t(base.v)
D3a <- rbind(D3a,base.mat)
}
}
return(D3a)
}
D3Bfunction <- function(alevel,blevel,clevel,ord=FALSE){
if(ord==FALSE){
D3b <- matrix(0,nrow=0,ncol=(alevel*blevel*clevel))
for(i in 1:(blevel-1)){
left.temp <- matrix(0,ncol=((i-1)*(alevel)),nrow=(alevel))
left.main <- -diag((alevel))
left.final <- cbind(left.temp,left.main)
for(j in (i+1):blevel){
middle.temp <- matrix(0,ncol=((j-i-1)*(alevel)),nrow=(alevel))
right.main <- diag((alevel))
right.temp <- matrix(0,ncol=((blevel-j)*(alevel)),nrow=(alevel))
right.final <- cbind(middle.temp,right.main,right.temp)
D2b <- cbind(left.final,right.final)
D3base <- diag(clevel) %x% D2b
D3b <- rbind(D3b, D3base)
}
}
}else if (ord==TRUE){
D3b <- matrix(0,nrow=0,ncol=(alevel*blevel*clevel))
for(i in 1:(blevel-1)){
left <- matrix(0,ncol=((i-1)*(alevel)),nrow=(alevel))
Main <- cbind(-diag((alevel)),diag((alevel)))
right <- matrix(0,ncol=((blevel-(i+1))*(alevel)),nrow=(alevel))
D2b <- cbind(left,Main,right)
D3base <- diag(clevel) %x% D2b
D3b <- rbind(D3b, D3base)
}
}
return(D3b)
}
D3Cfunction <- function(alevel,blevel,clevel,ord=FALSE){
if(ord==FALSE){
D3c <- matrix(0,nrow=0,ncol=(alevel*blevel*clevel))
for(i in 1:(clevel-1)){
left.temp <- matrix(0,ncol=((i-1)*(alevel*blevel)),nrow=(alevel*blevel))
left.main <- -diag((alevel*blevel))
left.final <- cbind(left.temp,left.main)
for(j in (i+1):clevel){
middle.temp <- matrix(0,ncol=((j-i-1)*(alevel*blevel)),nrow=(alevel*blevel))
right.main <- diag((alevel*blevel))
right.temp <- matrix(0,ncol=((clevel-j)*(alevel*blevel)),
nrow=(alevel*blevel))
right.final <- cbind(middle.temp,right.main,right.temp)
D3c <- rbind(D3c,cbind(left.final,right.final))
}
}
}else if (ord==TRUE){
Left <- cbind(-diag((alevel*blevel)*(clevel-1)),
matrix(0,ncol=(alevel*blevel),nrow=(alevel*blevel)*(clevel-1)))
Right <- cbind(matrix(0,ncol=(alevel*blevel),nrow=(alevel*blevel)*(clevel-1)),
diag((alevel*blevel)*(clevel-1)))
D3c <- Left + Right
}
return(D3c)
}
D2function <- function(alevel,blevel,type,ordAB){
if(type=="A"){
D2 <- D2Afunction(alevel=alevel,blevel=blevel,ord=ordAB[1])
}else if(type=="B"){
D2 <- D2Bfunction(alevel=alevel,blevel=blevel,ord=ordAB[2])
}
return(D2)
}
D2Afunction <- function(alevel,blevel,ord=FALSE){
D2a <- matrix(0,nrow=0,ncol=(alevel*blevel))
if(ord==FALSE){
for(i in 1:(alevel-1)){
for(j in (i+1):alevel){
base.v <- rep(0,alevel)
base.v[i] <- -1
base.v[j] <- 1
base.mat <- diag(blevel) %x% t(base.v)
D2a <- rbind(D2a,base.mat)
}
}
}else if(ord==TRUE){
for(i in 1:(alevel-1)){
base.v <- rep(0,alevel)
base.v[i] <- -1
base.v[(i+1)] <- 1
base.mat <- diag(blevel) %x% t(base.v)
D2a <- rbind(D2a,base.mat)
}
}
return(D2a)
}
D2Bfunction <- function(alevel,blevel,ord=FALSE){
if(ord==FALSE){
D2b <- matrix(0,nrow=0,ncol=(alevel*blevel))
for(i in 1:(blevel-1)){
left.temp <- matrix(0,ncol=((i-1)*(alevel)),nrow=(alevel))
left.main <- -diag((alevel))
left.final <- cbind(left.temp,left.main)
for(j in (i+1):blevel){
middle.temp <- matrix(0,ncol=((j-i-1)*(alevel)),nrow=(alevel))
right.main <- diag((alevel))
right.temp <- matrix(0,ncol=((blevel-j)*(alevel)),nrow=(alevel))
right.final <- cbind(middle.temp,right.main,right.temp)
D2b <- rbind(D2b,cbind(left.final,right.final))
}
}
}else if (ord==TRUE){
Left <- cbind(-diag((alevel)*(blevel-1)),matrix(0,ncol=alevel,nrow=(alevel)*(blevel-1)))
Right <- cbind(matrix(0,ncol=alevel,nrow=(alevel)*(blevel-1)), diag((alevel)*(blevel-1)))
D2b <- Left + Right
}
return(D2b)
}
D1function <- function(nlevel,ord=FALSE){
if(ord==FALSE){
qp = (nlevel)*(nlevel-1)/2
D1.mat <- matrix(0,ncol=(nlevel),nrow=0)
if (qp==1) D1.mat <- matrix(c(-1,1),ncol=2,nrow=1)
if (qp>1){
for(i in 1 : (nlevel-1)){
w.diag <- diag((nlevel-i))
left.v <- c(rep(0,(i-1)),-1)
left.mat <- matrix(rep(left.v,(nlevel-i)),nrow=(nlevel-i),byrow=TRUE)
w.mat <- cbind(left.mat,w.diag)
D1.mat <- rbind(D1.mat,w.mat)
}
}
}else if(ord==TRUE){
if(nlevel==2){
D1.mat <- matrix(c(-1,1),ncol=2,nrow=1)
}else{
D1.mat <- cbind(0,diag(nlevel-1)) + cbind(-diag(nlevel-1),0)
}
}
return(D1.mat)
}
if(dif==TRUE){
data1 <- data[side==1,]
data2 <- data[side==0,]
model.frame <- model.frame(formula,data=data1)
contr <- rep(list("contr.sum"), ncol(model.frame) - 1)
names(contr) <- colnames(model.frame)[-1]
y <- model.frame[,1]
x1 <- model.matrix(formula, data=data1,contrast=contr)[,-1]
x2 <- model.matrix(formula, data=data2,contrast=contr)[,-1]
X <- x1-x2
}else if (dif==FALSE){
model.frame <- model.frame(formula,data=data)
contr <- rep(list("contr.sum"), ncol(model.frame) - 1)
names(contr) <- colnames(model.frame)[-1]
y <- model.frame[,1]
X <- model.matrix(formula, data=data,contrast=contr)[,-1]
}
lm.fit <- lm(y ~ X)
coef.use <- coef(lm.fit)[-1]
levelIndex <- CreatelevelIndex(fac.level=(fac.level-1),ord.fac=ord.fac,Gorder=Gorder,
indTwo=indTwo, indThree=indThree)
use.ind <- (levelIndex$plus==1)*(levelIndex$dif==0)
Index.use <- levelIndex[use.ind==1,]
Fac.index <- levelIndex[,regexpr("Fac",colnames(levelIndex))>0]
Fac.Ind.use <- Fac.index[use.ind==1,]
Fac.level.useC <- (rep(1,nrow(Fac.Ind.use)) %x% t((fac.level-1))) * Fac.Ind.use
Fac.level.use <- (rep(1,nrow(Fac.Ind.use)) %x% t((fac.level))) * Fac.Ind.use
Index.use$start <- c(1,cumsum(Index.use$length)[-nrow(Index.use)]+1)
Index.use$end <- cumsum(Index.use$length)
if(Gorder==2){
Index.use$seq.order <- c(seq(1:sum(Index.use$order==1)),
seq(1:sum(Index.use$order==2)))
}else if(Gorder==3){
Index.use$seq.order <- c(seq(1:sum(Index.use$order==1)),
seq(1:sum(Index.use$order==2)),
seq(1:sum(Index.use$order==3)))
}
Coef.list <- CreateCoef(coef.use=coef.use,
Index.use=Index.use,
Fac.level.use=Fac.level.useC,
Gorder=Gorder)
if(facCons==TRUE){
n.fac <- length(fac.level)
MainDif <- list()
IntDif <- list()
ThreeDif <- list()
for(z in 1:n.fac){
Maincoef <- Coef.list$One.coef[[z]]
MainD1 <- D1function(nlevel=fac.level[z],ord=ord.fac[z])
MainDif[[z]] <- t(MainD1 %*% Maincoef)
}
ind.use.Two <- (Index.use$order==2)
Index.useTwo <- Index.use[ind.use.Two==1,]
Fac.useTwo <- Fac.Ind.use[ind.use.Two==1,]
Fac.level.useTwo <- Fac.level.use[ind.use.Two==1,]
for(z in 1:nrow(Index.useTwo)){
level.use <- as.numeric(Fac.level.useTwo[z,Fac.useTwo[z, ]==1])
ord.use <- ord.fac[Fac.useTwo[z, ]==1]
coef.int <- c(Coef.list$Two.coef[[z]])
D2A <- D2function(alevel=level.use[1],blevel=level.use[2],
type="A",ordAB=ord.use)
D2B <- D2function(alevel=level.use[1],blevel=level.use[2],
type="B",ordAB=ord.use)
IntDif.A <- D2A %*% coef.int
IntDif.B <- D2B %*% coef.int
IntDif[[z]] <- c(IntDif.A, IntDif.B)
if(Gorder>2){
ind.use.Three <- (Index.use$order==3)
Index.useThree <- Index.use[ind.use.Three==1,]
Fac.useThree <- Fac.Ind.use[ind.use.Three==1,]
Fac.level.useThree <- Fac.level.use[ind.use.Three==1,]
ThreeDif <- list()
for(z in 1:nrow(Index.useThree)){
level.use <- as.numeric(Fac.level.useThree[z,Fac.useThree[z, ]==1])
ord.use <- ord.fac[Fac.useThree[z, ]==1]
D3A <- D3function(alevel=level.use[1],blevel=level.use[2],clevel=level.use[3],
type="A",ordABC=ord.use)
D3B <- D3function(alevel=level.use[1],blevel=level.use[2],clevel=level.use[3],
type="B",ordABC=ord.use)
D3C <- D3function(alevel=level.use[1],blevel=level.use[2],clevel=level.use[3],
type="C",ordABC=ord.use)
coef.three <- c(Coef.list$Three.coef[[z]])
ThreeDif.A <- D3A %*% coef.three
ThreeDif.B <- D3B %*% coef.three
ThreeDif.C <- D3C %*% coef.three
ThreeDif[[z]] <- c(ThreeDif.A, ThreeDif.B, ThreeDif.C)
}
}
}
Main.max <- unlist(lapply(1:length(MainDif),function(x) 1/max(abs(MainDif[[x]]))))
Int.max <- unlist(lapply(1:length(IntDif),function(x) 1/max(abs(IntDif[[x]]))))
if(Gorder > 2){
Three.max <- unlist(lapply(1:length(ThreeDif),function(x) 1/max(abs(ThreeDif[[x]]))))
weight <- c(Main.max,Int.max, Three.max)
}else if(Gorder==2){
weight <- c(Main.max,Int.max)
}
}
else if(facCons==FALSE){
Maincoef <- Coef.list$One.coef[[type.ind]]
MainD1 <- D1function(nlevel=fac.level[type.ind],ord=ord.fac[type.ind])
MainDif <- t(MainD1 %*% Maincoef)
qp <- ncol(MainDif)
onlyOne <- sum(Fac.Ind.use[type.ind])==1
yesTwo <- sum((Index.use$order==2)*(Fac.Ind.use[type.ind]==1))>0
yesThree <- sum((Index.use$order==3)*(Fac.Ind.use[type.ind]==1))>0
if(onlyOne==TRUE){
Dif <- abs(MainDif)
}else if(yesTwo==TRUE){
ind.use.Two <- (Index.use$order==2)*(Fac.Ind.use[type.ind]==1)
Index.useTwo <- Index.use[ind.use.Two==1,]
Fac.useTwo <- Fac.Ind.use[ind.use.Two==1,]
Fac.level.useTwo <- Fac.level.use[ind.use.Two==1,]
IntDif <- matrix(0,nrow=0,ncol=qp)
for(z in 1:nrow(Index.useTwo)){
level.use <- as.numeric(Fac.level.useTwo[z,Fac.useTwo[z, ]==1])
ord.use <- ord.fac[Fac.useTwo[z, ]==1]
if(min(which(Fac.useTwo[z,]==1))==type.ind){
type.d2 <- "A"}else{ type.d2 <- "B" }
D2 <- D2function(alevel=level.use[1],blevel=level.use[2],
type=type.d2,ordAB=ord.use)
coef.int <- c(Coef.list$Two.coef[[Index.useTwo[z,"seq.order"]]])
IntDif.t <- D2 %*% coef.int
IntDif.mat <- matrix(IntDif.t,ncol=qp)
IntDif <- rbind(IntDif, IntDif.mat)
}
if(yesThree==FALSE){
Dif <- abs(rbind(MainDif,IntDif))
}else if(yesThree==TRUE){
ind.use.Three <- (Index.use$order==3)*(Fac.Ind.use[type.ind]==1)
Index.useThree <- Index.use[ind.use.Three==1,]
Fac.useThree <- Fac.Ind.use[ind.use.Three==1,]
Fac.level.useThree <- Fac.level.use[ind.use.Three==1,]
ThreeDif <- matrix(0,nrow=0,ncol=qp)
for(z in 1:nrow(Index.useThree)){
level.use <- as.numeric(Fac.level.useThree[z,Fac.useThree[z, ]==1])
ord.use <- ord.fac[Fac.useThree[z, ]==1]
if(min(which(Fac.useThree[z,]==1))==type.ind){
type.d3 <- "A"
}else if (max(which(Fac.useThree[z,]==1))==type.ind){
type.d3 <- "C"
}else{ type.d3 <- "B"}
D3 <- D3function(alevel=level.use[1],blevel=level.use[2],clevel=level.use[3],
type=type.d3,ordABC=ord.use)
coef.three <- c(Coef.list$Three.coef[[Index.useThree[z,"seq.order"]]])
ThreeDif.t <- D3 %*% coef.three
ThreeDif.mat <- matrix(ThreeDif.t,ncol=qp)
ThreeDif <- rbind(ThreeDif, ThreeDif.mat)
}
Dif <- abs(rbind(MainDif,IntDif,ThreeDif))
}
}
weight <- apply(Dif,2,function(x) 1/max(abs(x)))
}
levelIndex <- CreatelevelIndex(fac.level=(fac.level),ord.fac=ord.fac, Gorder=Gorder,
indTwo=indTwo, indThree=indThree)
use.ind <- (levelIndex$plus==1)*(levelIndex$dif==1) * (levelIndex$order==1)
Index.use <- levelIndex[use.ind==1,]
temp.w <- 1/(sqrt(fac.level[type.ind])*(fac.level[type.ind]+1))
weight.u <- rep(temp.w, times=Index.use$length[type.ind])
output <- list("weight.ols"=weight, "weight.fac"=weight.u)
return(output)
}
|
setClass("Exhaustive.model.search.algorithm",
contains = "Model.search.algorithm"
)
|
q.mle.emg.estimate <- function(complete.lifespans, censored.lifespans)
{
mle(function(mu, sigma, lambda, Q)
{
qsurvival.nllik("emg", complete.lifespans, censored.lifespans, Q, mu, sigma, lambda)
},
method='L-BFGS-B',
lower=list(mu=8, sigma=0.1, lambda=0.01, Q=0),
upper=list(mu=30, sigma=(max(complete.lifespans) - min(complete.lifespans)),
lambda=10, Q=0.999999),
start=list(mu=median(complete.lifespans),
sigma=sd(complete.lifespans),
lambda=1/mean(complete.lifespans),
Q = 0.5))
}
|
dcsd <-
function(object, ...)
{
UseMethod("dcsd")
}
|
phylomatic_tree <- function(...) {
.Defunct(msg = "This function is defunct - See ?`taxize-defunct`")
}
|
hypothesis.test.result = function(p.value, alpha.warning=0.05, alpha.failure = 0.0001, verbose=FALSE) {
if (p.value < alpha.failure) {
if (verbose)
message(" H0 is highly significantly rejected... check fails!")
return(FALSE)
} else if (p.value < alpha.warning) {
if (verbose)
message(paste0(" H0 signicantly rejected... warning!"))
return("warning")
} else {
if (verbose)
cat(paste0("... ok!"))
return(TRUE)
}
}
sigma.test = function (x, sigma = 1, sigmasq = sigma^2,
alternative = c("two.sided", "less", "greater"),
conf.level = 0.95, ...) {
alternative <- match.arg(alternative)
sigma <- sqrt(sigmasq)
n <- length(x)
xs <- var(x)*(n-1)/sigma^2
out <- list(statistic = c("X-squared" = xs))
class(out) <- "htest"
out$parameter <- c(df = n-1)
minxs <- min(c(xs, 1/xs))
maxxs <- max(c(xs, 1/xs))
PVAL <- pchisq(xs, df = n - 1)
out$p.value <- switch(alternative,
two.sided = 2*min(PVAL, 1 - PVAL),
less = PVAL,
greater = 1 - PVAL)
out$conf.int <- switch(alternative,
two.sided = xs * sigma^2 *
1/c(qchisq(1-(1-conf.level)/2, df = n-1), qchisq((1-conf.level)/2, df
= n-1)),
less = c(0, xs * sigma^2 /
qchisq(1-conf.level, df = n-1)),
greater = c(xs * sigma^2 /
qchisq(conf.level, df = n-1), Inf))
attr(out$conf.int, "conf.level") <- conf.level
out$estimate <- c("var of x" = var(x))
out$null.value <- c(variance = sigma^2)
out$alternative <- alternative
out$method <- "One sample Chi-squared test for variance"
out$data.name <- deparse1(substitute(x))
names(out$estimate) <- paste("var of", out$data.name)
return(out)
}
test.H0.rejected = function(test.expr,p.value,test.name="",
alpha.warning = 0.01,alpha.failure =0.05,
short.message="Fail to reject '{{test_name}}', p.value = {{p_value}}",
warning.message="The null hypothesis from the test '{{test_name}}', should not be rejcected, but I get a fairly low p.value of {{p_value}}.",
failure.message="I couldn't significantly reject the null hypothesis from the test '{{test_name}}', p.value = {{p_value}}",
success.message = "Great, I could significantly reject the null hypothesis from the test '{{test_name}}', p.value = {{p_value}}!",
check.warning=TRUE, ps=get.ps(),stud.env = ps$stud.env, part=NULL,...)
{
if (!missing(test.expr)) {
test.expr = substitute(test.expr)
if (test.name=="") {
test.name = deparse1(test.expr)
}
}
if (missing(p.value)) {
test.res = eval(test.expr, stud.env)
p.value = test.res$p.value
}
if (p.value > alpha.failure) {
add.failure(failure.message,test_name=test.name,p_value=p.value)
return(FALSE)
}
add.success(success.message,test_name=test.name,p_value=p.value)
if (p.value > alpha.warning & check.warning) {
add.warning(warning.message,test_name=test.name,p_value=p.value)
return("warning")
}
return(TRUE)
}
test.H0 = function(test.expr,p.value,test.name="",
alpha.warning = 0.05,alpha.failure =0.001,
short.message,warning.message,failure.message,
success.message = "Great, I could not significantly reject the null hypothesis from the test '{{test_name}}', p.value = {{p_value}}!",
check.warning=TRUE, part=NULL,
ps=get.ps(),stud.env = ps$stud.env,...) {
if (!missing(test.expr)) {
test.expr = substitute(test.expr)
if (test.name=="") {
test.name = deparse1(test.expr)
}
}
if (missing(p.value)) {
test.res = eval(test.expr, stud.env)
p.value = test.res$p.value
}
if (missing(short.message)) {
short.message = paste0("rejected '{{test_name}}' has p.value = {{p_value}}")
}
if (missing(failure.message)) {
failure.message = paste0("The null hypothesis from the test '{{test_name}}' shall hold, but it is rejected at p.value = {{p_value}}")
}
if (missing(warning.message)) {
warning.message = paste0("The null hypothesis from the test '{{test_name}}', should not be rejcected, but I get a fairly low p.value of {{p_value}}.")
}
if (p.value < alpha.failure) {
add.failure(failure.message,test_name=test.name,p_value=p.value,...)
return(FALSE)
}
add.success(success.message,test_name=test.name,p_value=p.value,...)
if (p.value < alpha.warning & check.warning) {
add.warning(warning.message,test_name=test.name,p_value=p.value,...)
return("warning")
}
return(TRUE)
}
test.variance = function(vec, true.val, test = "t.test",short.message,warning.message,failure.message, success.message = "Great, I cannot statistically reject that {{var}} has the desired variance {{vari_sol}}!", ps=get.ps(),stud.env = ps$stud.env,part=NULL,...) {
call.str = as.character(match.call())
var.name = call.str[2]
p.value = sigma.test(vec,sigmasq=true.val)$p.value
if (missing(short.message)) {
short.message ="wrong variance {{var}}: is {{vari_stud}} shall {{vari_sol}}, p.value = {{p_value}}"
}
if (missing(failure.message)) {
failure.message = "{{var}} has wrong variance! \n Your random variable {{var}} has a sample variance of {{vari_stud}} but shall have {{vari_sol}}. A chi-square test tells me that if that null hypothesis were true, it would be very unlikely (p.value={{p_value}}) to get a sample as extreme as yours!"
}
if (missing(warning.message)) {
warning.message = "{{var}} has a suspicious variance! \n Your random variable {{var}} has a sample variance of {{vari_stud}} but shall have {{vari_sol}}. A chi-square test tells me that if that null hypthesis were true, the probability would be just around {{p_value}} to get such an extreme sample variance"
}
test.H0(p.value=p.value,short.message=short.message, warning.message=warning.message, failure.message=failure.message, success.message=success.message,
var = var.name, vari_stud = var(vec), vari_sol=true.val,...)
}
test.mean = function(vec, true.val, test = "t.test", short.message,warning.message,failure.message, success.message = "Great, I cannot statistically reject that {{var}} has the desired mean of {{mean_sol}}!", ps=get.ps(),stud.env = ps$stud.env,part=NULL,...) {
call.str = as.character(match.call())
stopifnot(test=="t.test")
var.name = call.str[2]
p.value = t.test(vec,mu=true.val)$p.value
if (missing(short.message)) {
short.message ="wrong mean {{var}}: is {{mean_stud}} shall {{mean_sol}}, p.value = {{p_value}}"
}
if (missing(failure.message)) {
failure.message = "{{var}} has wrong mean! \n Your random variable {{var}} has a sample mean of {{mean_stud}} but shall have {{mean_sol}}. A t-test tells me that if that null hypothesis were true, it would be very unlikely (p.value={{p_value}}) to get a sample mean as extreme as yours!"
}
if (missing(warning.message)) {
warning.message = "{{var}} has a suspicious mean!\n Your random variable {{var}} has a sample mean of {{mean_stud}} but shall have {{mean_sol}}. A t-test tells me that if that null hypthesis were true, the probability would be just around {{p_value}} to get such an extreme sample mean_"
}
test.H0(p.value=p.value,short.message=short.message, warning.message=warning.message, failure.message=failure.message,success.message=success.message,
var = var.name, mean_stud = mean(vec), mean_sol=true.val,...)
}
test.normality = function(vec,short.message,warning.message,failure.message,ps=get.ps(),stud.env = ps$stud.env, success.message = "Great, I cannot statistically reject that {{var}} is indeed normally distributed!",part=NULL,...) {
call.str = as.character(match.call())
restore.point("test.normality")
var.name=call.str[2]
if (length(vec)>5000)
vec = vec[sample.int(n=length(vec), size=5000)]
p.value = shapiro.test(vec)$p.value
if (missing(short.message)) {
short.message ="{{var}} not normally distributed, p.value = {{p_value}}"
}
if (missing(failure.message)) {
failure.message = "{{var}} looks really not normally distributed.\n A Shapiro-Wilk test rejects normality at an extreme significance level of {{p_value}}."
}
if (missing(warning.message)) {
warning.message = "{{var}} looks not very normally distributed.\n A Shapiro-Wilk test rejects normality at a significance level of {{p_value}}."
}
test.H0(p.value=p.value,short.message=short.message, warning.message=warning.message, failure.message=failure.message,success.message=success.message,
var = var.name,...)
}
|
suppressMessages(library(fields))
test.for.zero.flag<- 1
x0<- expand.grid( c(-8,-4,0,20,30), c(10,8,4,0))
Krig( ChicagoO3$x, ChicagoO3$y, cov.function = "Exp.cov", aRange=50)-> out
Krig.Amatrix( out, x=x0)-> A
test.for.zero( A%*%ChicagoO3$y, predict( out, x0),tag="Amatrix vs. predict")
Sigma<- out$sigmahat*Exp.cov( ChicagoO3$x, ChicagoO3$x, aRange=50)
S0<- out$sigmahat*c(Exp.cov( x0, x0, aRange=50))
S1<- out$sigmahat*Exp.cov( out$x, x0, aRange=50)
look<- S0 - t(S1)%*% t(A) - A%*%S1 +
A%*% ( Sigma + diag(out$tauHat.MLE**2/out$weightsM))%*% t(A)
test2<- predictSE( out, x= x0)
test.for.zero( sqrt(diag( look)), test2,tag="Marginal predictSE")
out2<- Krig( ChicagoO3$x, ChicagoO3$y, cov.function = "Exp.cov", aRange=50,
lambda=out$lambda)
test2<- predictSE( out2, x= x0)
test.for.zero( sqrt(diag( look)), test2,tag="Marginal predictSE fixed ")
test<- predictSE( out, x= x0, cov=TRUE)
test.for.zero( look, test,tag="Full covariance predictSE")
set.seed( 333)
sim.Krig( out, x0,M=4e3)-> test
var(test)-> look
predictSE( out, x=x0)-> test2
mean( diag( look)/ test2**2)-> look2
test.for.zero(look2, 1.0, tol=1.5e-2, tag="Marginal standard Cond. Sim.")
predictSE( out, x=x0, cov=TRUE)-> test2
eigen( test2, symmetric=TRUE)-> hold
hold$vectors%*% diag( 1/sqrt( hold$values))%*% t( hold$vectors)-> hold
cor(test%*% hold)-> hold2
abs(hold2[ col(hold2)> row( hold2)])-> hold3
test.for.zero( mean(hold3), 0, relative=FALSE, tol=.02,
tag="Full covariance standard Cond. Sim.")
data( ozone2)
as.image(ozone2$y[16,], x= ozone2$lon.lat, ny=24, nx=20,
na.rm=TRUE)-> dtemp
x<- dtemp$xd
y<- dtemp$z[ dtemp$ind]
weights<- dtemp$weights[ dtemp$ind]
Krig( x, y, Covariance="Matern",
aRange=1.0, smoothness=1.0, weights=weights) -> out
set.seed(234)
ind0<- cbind( sample( 1:20, 5), sample( 1:24, 5))
x0<- cbind( dtemp$x[ind0[,1]], dtemp$y[ind0[,2]])
Krig.Amatrix( out, x=x0)-> A
test.for.zero( A%*%out$yM, predict( out, x0),tag="Amatrix vs. predict")
Sigma<- out$sigmahat*stationary.cov(
out$xM, out$xM, aRange=1.0,smoothness=1.0, Covariance="Matern")
S0<- out$sigmahat*stationary.cov(
x0, x0, aRange=1.0,smoothness=1.0, Covariance="Matern")
S1<- out$sigmahat*stationary.cov(
out$xM, x0, aRange=1.0,smoothness=1.0, Covariance="Matern")
look<- S0 - t(S1)%*% t(A) - A%*%S1 +
A%*% ( Sigma + diag(out$tauHat.MLE**2/out$weightsM) )%*% t(A)
test<- predictSE( out, x0, cov=TRUE)
test.for.zero( c( look), c( test), tag="Weighted case and exact for ozone2 full
cov", tol=1e-8)
cat("all done testing predictSE ", fill=TRUE)
options( echo=TRUE)
|
knitr::opts_chunk$set(
collapse = TRUE,
comment = "
)
library(ggmix)
data("admixed")
names(admixed)
popkin::plot_popkin(admixed$kin_train)
fit <- ggmix(x = admixed$xtrain,
y = admixed$ytrain,
kinship = admixed$kin_train)
names(fit)
class(fit)
plot(fit)
coef(fit, s = c(0.1,0.02))
head(predict(fit, s = 0.01, newx = admixed$xtest))
hdbic <- gic(fit)
class(hdbic)
bicfit <- gic(fit, an = log(length(admixed$ytrain)))
plot(hdbic)
hdbic[["lambda.min"]]
plot(bicfit, ylab = "BIC")
bicfit[["lambda.min"]]
coef(hdbic)
coef(hdbic, type = "nonzero")
predict(hdbic, newx = admixed$xtest)
plot(hdbic, type = "predicted", newx = admixed$xtrain, newy = admixed$ytrain)
plot(hdbic, type = "QQranef", newx = admixed$xtrain, newy = admixed$ytrain)
plot(hdbic, type = "QQresid", newx = admixed$xtrain, newy = admixed$ytrain)
plot(hdbic, type = "Tukey", newx = admixed$xtrain, newy = admixed$ytrain)
|
arrow3d <- function(p0=c(0,0,0), p1=c(1,1,1), barblen, s=0.05, theta=pi/6, n=3, ...){
if (!requireNamespace("rgl")) stop("rgl package is required.")
extprod3d <- function (x, y)
{
x = matrix(x, ncol = 3)
y = matrix(y, ncol = 3)
drop(cbind(x[, 2] * y[, 3] - x[, 3] * y[, 2], x[, 3] * y[,
1] - x[, 1] * y[, 3], x[, 1] * y[, 2] - x[, 2] * y[,
1]))
}
phi=seq(0,2*pi,len=n+1)[-1]
lp = sqrt(sum((p1-p0)^2))
if (missing(barblen)) {
barblen <- s*lp
}
cpt=(1-(barblen*cos(theta)))*(p1-p0)
line = rgl::lines3d(c(p0[1],p1[1]),c(p0[2],p1[2]),c(p0[3],p1[3]),...)
rpt = jitter(c(
runif(1,min(p0[1],p1[1]),max(p0[1],p1[1])),
runif(1,min(p0[2],p1[2]),max(p0[2],p1[2])),
runif(1,min(p0[3],p1[3]),max(p0[3],p1[3]))
))
r = extprod3d(p1-p0,rpt)
r = r / sqrt(sum(r^2))
pts = list()
for(i in 1:length(phi)){
ptb=rgl::rotate3d(r,phi[i],(p1-p0)[1],(p1-p0)[2],(p1-p0)[3])
rgl::lines3d(
c(p1[1],cpt[1]+p0[1]+barblen*sin(theta)*ptb[1]),
c(p1[2],cpt[2]+p0[2]+barblen*sin(theta)*ptb[2]),
c(p1[3],cpt[3]+p0[3]+barblen*sin(theta)*ptb[3]),
...
)
}
invisible(line)
}
|
checkCall <- function(){
badCall <- lapply(sys.calls(), "[[", 1) %in% c("model.frame.default",
"model.matrix.default")
if (any(badCall))
stop(paste(sys.call(-1)[[1]], "terms are only valid in gnm models."))
}
|
get_fiscal <- function(year,
period,
cod,
freq = "Q",
annex = NULL,
power = c("E", "L", "J", "M", "D"),
verbose = FALSE) {
get(
type = "rgf",
an_exercicio = year,
nr_periodo = period,
id_ente = cod,
in_periodicidade = freq,
co_tipo_demonstrativo = if (freq == "Q") "RGF" else "RGF Simplificado",
no_anexo = if (!is.null(annex)) paste0("RGF-Anexo 0", annex) else annex,
co_poder = power,
verbose = verbose
)
}
|
get_my_profile <- function(authorization = get_spotify_authorization_code()) {
base_url <- 'https://api.spotify.com/v1/me/'
res <- RETRY('GET', base_url, config(token = authorization), encode = 'json')
stop_for_status(res)
res <- fromJSON(content(res, as = 'text', encoding = 'UTF-8'), flatten = TRUE)
res <- t(unlist(res))
return(res)
}
get_user_profile <- function(user_id, authorization = get_spotify_access_token()) {
base_url <- 'https://api.spotify.com/v1/users'
url <- paste0(base_url, "/", user_id)
params = list(access_token = authorization)
res <- RETRY('GET', url, query = params, encode = 'json')
stop_for_status(res)
res <- fromJSON(content(res, as = 'text', encoding = 'UTF-8'), flatten = TRUE)
res <- fromJSON(content(res, as = 'text', encoding = 'UTF-8'), flatten = TRUE)
res <- t(unlist(res))
return(res)
}
|
opt62 <- eventReactive(input$RunOpt62, {
Gprint(MODE_DEBUG, "Opt62\n")
ficout = tempfile()
ficin = GenepopFile()$datapath
out = TRUE
if (is.null(ficin)) {
out = FALSE
} else {
Gprint(MODE_DEBUG, ficin)
datatype = input$ploidy62
setRandomSeed(getSeed(input$randomSeed))
show("spinner")
tryCatch(Fst(ficin, pairs = TRUE, outputFile = ficout, dataType = datatype), error = function(e) {
file.create(ficout)
write(paste("Exeption : ", e$message), file = ficout)
}, finally = hide("spinner"))
file.rename("cmdline.txt", "cmdline.old")
}
data.frame(file = ficout, output = out)
})
output$Opt62out <- renderText({
opt <- opt62()
if (opt$output) {
filePath <- toString(opt$file)
if (file.size(filePath) > 300) {
fileText <- readLines(filePath)
nblig = grep("Number of loci detected", fileText)
fileText <- paste(fileText[(nblig + 2):length(fileText)], collapse = "\n")
shinyjs::enable("downloadOpt62All")
} else {
fileText <- readLines(filePath)
}
} else {
fileText <- "No genepop file found! please upload a file"
}
fileText
})
output$downloadOpt62All <- downloadHandler(filename = function() {
paste("result_opt62_", Sys.Date(), ".txt", sep = "")
}, content = function(con) {
opt <- opt62()
if (opt$output) {
filePath <- toString(opt$file)
fileText <- readLines(filePath)
} else {
fileText <- "No genepop file found! please upload a file"
}
write(fileText, con)
})
|
runModule.get.trait.data <- function(settings) {
if (is.null(settings$meta.analysis)) return(settings)
if (PEcAn.settings::is.MultiSettings(settings)) {
pfts <- list()
pft.names <- character(0)
for (i in seq_along(settings)) {
pfts.i <- settings[[i]]$pfts
if (!is.list(pfts.i)) {
PEcAn.logger::logger.severe("settings[[i]]$pfts is not a list")
}
pft.names.i <- sapply(pfts.i, function(x) x$name)
ind <- which(pft.names.i %in% setdiff(pft.names.i, pft.names))
pfts <- c(pfts, pfts.i[ind])
pft.names <- sapply(pfts, function(x) x$name)
}
PEcAn.logger::logger.info(paste0("Getting trait data for all PFTs listed by any Settings object in the list: ",
paste(pft.names, collapse = ", ")))
modeltype <- settings$model$type
dbfiles <- settings$database$dbfiles
database <- settings$database$bety
forceupdate <- ifelse(is.null(settings$meta.analysis$update), FALSE, settings$meta.analysis$update)
settings$pfts <- PEcAn.DB::get.trait.data(pfts = pfts, modeltype = modeltype, dbfiles = dbfiles, database = database, forceupdate = forceupdate)
return(settings)
} else if (PEcAn.settings::is.Settings(settings)) {
pfts <- settings$pfts
if (!is.list(pfts)) {
PEcAn.logger::logger.severe("settings$pfts is not a list")
}
modeltype <- settings$model$type
dbfiles <- settings$database$dbfiles
database <- settings$database$bety
forceupdate <- ifelse(is.null(settings$meta.analysis$update), FALSE, settings$meta.analysis$update)
settings$pfts <- PEcAn.DB::get.trait.data(pfts = pfts, modeltype = modeltype, dbfiles = dbfiles, database = database, forceupdate = forceupdate)
return(settings)
} else {
stop("runModule.get.trait.data only works with Settings or MultiSettings")
}
}
|
pull_genoprobpos <-
function(genoprobs, map=NULL, chr=NULL, pos=NULL, marker=NULL)
{
if(is.null(genoprobs)) stop("genoprobs is NULL")
if(is.character(map) && is.null(chr) && is.null(pos) && is.null(marker)) {
marker <- map
map <- NULL
}
if(!is.null(marker) && (!is.null(map) || !is.null(chr) || !is.null(pos))) {
warning("Provide either {map,chr,pos} or marker, not both; using marker")
}
if(is.null(marker)) {
marker <- find_marker(map, chr, pos)
}
if(length(marker) == 0) stop("marker has length 0")
if(length(marker) > 1) {
marker <- marker[1]
warning("marker should have length 1; using the first value")
}
markers <- dimnames(genoprobs)[[3]]
chr <- rep(names(genoprobs), lapply(markers, length))
index <- unlist(lapply(markers, function(a) seq_along(a)))
markers <- unlist(markers)
wh <- (marker == markers)
n_found <- sum(wh)
if(n_found==0) stop('marker "', marker, '" not found')
if(n_found > 1) stop('marker "', marker, '" appears ', n_found, ' times')
result <- genoprobs[[chr[wh]]][,,index[wh], drop=FALSE]
d <- dim(result)
dn <- dimnames(result)
result <- matrix(result[,,1], nrow=d[1], ncol=d[2])
dimnames(result) <- dn[1:2]
result
}
|
values_at <- function(x, values = "meansd") {
force(values)
.values_at <- function(x) {
values <- check_rv(values, x)
if (values == "minmax") {
mv.min <- min(x, na.rm = TRUE)
mv.max <- max(x, na.rm = TRUE)
xl <- c(mv.min, mv.max)
} else if (values == "zeromax") {
mv.max <- max(x, na.rm = TRUE)
xl <- c(0, mv.max)
} else if (values == "meansd") {
mv.mean <- mean(x, na.rm = TRUE)
mv.sd <- stats::sd(x, na.rm = TRUE)
xl <- c(mv.mean - mv.sd, mv.mean, mv.mean + mv.sd)
} else if (values == "all") {
xl <- as.vector(unique(sort(x, na.last = NA)))
} else if (values == "quart") {
xl <- as.vector(stats::quantile(x, na.rm = TRUE))
} else if (values == "quart2") {
xl <- as.vector(stats::quantile(x, na.rm = TRUE))[2:4]
}
if (is.numeric(x)) {
if (is.whole(x)) {
rv <- round(xl, 1)
if (length(unique(rv)) < length(rv))
rv <- unique(round(xl, 2))
} else
rv <- round(xl, 2)
if (length(unique(rv)) < length(rv)) {
rv <- unique(round(xl, 3))
if (length(unique(rv)) < length(rv))
rv <- unique(round(xl, 4))
}
} else {
rv <- xl
}
rv
}
if (missing(x)) {
.values_at
} else {
.values_at(x)
}
}
check_rv <- function(values, x) {
if ((is.factor(x) || is.character(x)) && values != "all") {
message(paste0("Cannot use '", values, "' for factors or character vectors. Defaulting `values` to `all`."))
values <- "all"
}
if (is.numeric(x)) {
mvc <- length(unique(as.vector(stats::quantile(x, na.rm = TRUE))))
if (values %in% c("quart", "quart2") && mvc < 3) {
message("Could not compute quartiles, too small range of variable. Defaulting `values` to `minmax`.")
values <- "minmax"
}
}
values
}
representative_values <- values_at
|
bls_request <- function(query, api_key = NA, user_agent = 'http://github.com/groditi/blsR' ){
ua <- httr::user_agent(user_agent)
url <- httr::parse_url(query$url)
if(query$is_complex == FALSE){
if(!is.na(api_key))
url <- httr::modify_url(url, query = c(url$query, list(registrationkey = api_key)))
response <- httr::GET(url, ua)
} else{
if('payload' %in% names(query)){
if('seriesid' %in% names(query$payload)){
if(is.na(api_key))
warning('api_key is required for multiple series requests.')
query$payload[['registrationkey']] <- api_key
}
}
response <- httr::POST(url=url, ua, body=query$payload, encode="json")
}
return(
tryCatch(
.process_response(response),
error = function(e) stop(paste(c('Error processing', url, e), ': '))
)
)
}
.process_response <- function(response){
if(httr::http_type(response) != "application/json"){
stop("http request did not return json", call. = FALSE)
}
json_response <- httr::content(response, simplifyVector=FALSE)
if(json_response$status != 'REQUEST_SUCCEEDED') {
stop(paste(json_response$message, '; '), call. = FALSE)
}
return(json_response$Results)
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.