code
stringlengths 1
13.8M
|
|---|
writeDefaultNamespace <-
function(filename, desc = file.path(dirname(filename), "DESCRIPTION"))
{
pkgInfo <- .split_description(.read_description(desc))
pkgs <- unique(c(names(pkgInfo$Imports), names(pkgInfo$Depends)))
pkgs <- pkgs[pkgs != "base"]
writeLines(c("
"
"",
"
"exportPattern(\".\")",
if (length(pkgs))
c("",
"
"import(",
paste0(" ", pkgs, collapse = ",\n"),
")")),
filename)
}
get_exclude_patterns <- function()
c("^\\.Rbuildignore$",
"(^|/)\\.DS_Store$",
"^\\.(RData|Rhistory)$",
"~$", "\\.bak$", "\\.swp$",
"(^|/)\\.
"^TITLE$", "^data/00Index$",
"^inst/doc/00Index\\.dcf$",
"^config\\.(cache|log|status)$",
"(^|/)autom4te\\.cache$",
"^src/.*\\.d$", "^src/Makedeps$",
"^src/so_locations$",
"^inst/doc/Rplots\\.(ps|pdf)$"
)
inRbuildignore <- function(files, pkgdir) {
exclude <- rep.int(FALSE, length(files))
ignore <- get_exclude_patterns()
ignore_file <- file.path(pkgdir, ".Rbuildignore")
if (file.exists(ignore_file))
ignore <- c(ignore, readLines(ignore_file, warn = FALSE))
for(e in ignore[nzchar(ignore)])
exclude <- exclude | grepl(e, files, perl = TRUE,
ignore.case = TRUE)
exclude
}
.build_packages <- function(args = NULL, no.q = interactive())
{
WINDOWS <- .Platform$OS.type == "windows"
Sys.umask("022")
writeLinesNL <- function(text, file)
{
con <- file(file, "wb")
on.exit(close(con))
writeLines(text, con)
}
system_with_capture <- function (command, args) {
outfile <- tempfile("xshell")
on.exit(unlink(outfile))
status <- system2(command, args, stdout=outfile, stderr=outfile)
list(status = status, stdout = readLines(outfile, warn = FALSE))
}
Ssystem <- function(command, args = character(), ...)
system2(command, args, stdout = NULL, stderr = NULL, ...)
do_exit <-
if(no.q)
function(status) (if(status) stop else message)(
".build_packages() exit status ", status)
else
function(status) q("no", status = status, runLast = FALSE)
parse_description_field <-
function(desc, field, default = TRUE, logical = TRUE)
str_parse(desc[field], default=default, logical=logical)
Usage <- function() {
cat("Usage: R CMD build [options] pkgdirs",
"",
"Build R packages from package sources in the directories specified by",
sQuote("pkgdirs"),
"",
"Options:",
" -h, --help print short help message and exit",
" -v, --version print version info and exit",
"",
" --force force removal of INDEX file",
" --keep-empty-dirs do not remove empty dirs",
" --no-build-vignettes do not (re)build package vignettes",
" --no-manual do not build the PDF manual even if \\Sexprs are present",
" --resave-data= re-save data files as compactly as possible:",
' "no", "best", "gzip" (default)',
" --resave-data same as --resave-data=best",
" --no-resave-data same as --resave-data=no",
" --compact-vignettes= try to compact PDF files under inst/doc:",
' "no" (default), "qpdf", "gs", "gs+qpdf", "both"',
" --compact-vignettes same as --compact-vignettes=qpdf",
" --compression= type of compression to be used on tarball:",
' "gzip" (default), "none", "bzip2", "xz"',
" --md5 add MD5 sums",
" --log log to file 'pkg-00build.log' when processing ",
" the pkgdir with basename 'pkg'",
"",
"Report bugs at <https://bugs.R-project.org>.", sep = "\n")
}
add_build_stamp_to_description_file <- function(ldpath, pkgdir)
{
db <- .read_description(ldpath)
if(dir.exists(file.path(pkgdir, "src")))
db["NeedsCompilation"] <- "yes"
else if(is.na(db["NeedsCompilation"]))
db["NeedsCompilation"] <- "no"
user <- Sys.info()["user"]
if(user == "unknown") user <- Sys.getenv("LOGNAME")
db["Packaged"] <-
sprintf("%s; %s",
format(Sys.time(), "%Y-%m-%d %H:%M:%S",
tz = 'UTC', usetz = TRUE),
user)
.write_description(db, ldpath)
}
add_expanded_R_fields_to_description_file <- function(ldpath) {
db <- .read_description(ldpath)
fields <- .expand_package_description_db_R_fields(db)
if(length(fields))
.write_description(c(db, fields), ldpath)
}
temp_install_pkg <- function(pkgdir, libdir) {
dir.create(libdir, mode = "0755", showWarnings = FALSE)
if(nzchar(install_dependencies) &&
all((repos <- getOption("repos")) != "@CRAN@")) {
available <- utils::available.packages(repos = repos)
db <- .read_description(file.path(pkgdir, "DESCRIPTION"))
package <- db["Package"]
available <-
rbind(available[available[, "Package"] != package, ,
drop = FALSE],
db[colnames(available)])
depends <- package_dependencies(package, available,
which = install_dependencies)
depends <- setdiff(unlist(depends),
utils::installed.packages())
if(length(depends)) {
message(paste(strwrap(sprintf("installing dependencies %s",
paste(sQuote(sort(depends)),
collapse = ", ")),
exdent = 2L),
collapse = "\n"), domain = NA)
utils::install.packages(depends,
libdir,
available =
available[-nrow(available), ,
drop = FALSE],
dependencies = NA)
}
}
if (WINDOWS) {
cmd <- file.path(R.home("bin"), "Rcmd.exe")
args <- c("INSTALL -l", shQuote(libdir),
"--no-multiarch", shQuote(pkgdir))
} else {
cmd <- file.path(R.home("bin"), "R")
args <- c("CMD", "INSTALL -l", shQuote(libdir),
"--no-multiarch", shQuote(pkgdir))
}
res <- system_with_capture(cmd, args)
if (res$status) {
printLog(Log, " -----------------------------------\n")
printLog0(Log, paste(c(res$stdout, ""), collapse = "\n"))
printLog(Log, " -----------------------------------\n")
unlink(libdir, recursive = TRUE)
printLog(Log, "ERROR: package installation failed\n")
do_exit(1L)
}
Sys.setenv("R_BUILD_TEMPLIB" = libdir)
TRUE
}
prepare_pkg <- function(pkgdir, desc, Log)
{
owd <- setwd(pkgdir); on.exit(setwd(owd))
checkingLog(Log, "DESCRIPTION meta-information")
res <- try(.check_package_description("DESCRIPTION"))
if (inherits(res, "try-error")) {
resultLog(Log, "ERROR")
messageLog(Log, "running '.check_package_description' failed")
} else {
if (any(lengths(res))) {
resultLog(Log, "ERROR")
print(res)
do_exit(1L)
} else resultLog(Log, "OK")
}
cleanup_pkg(pkgdir, Log)
libdir <- tempfile("Rinst")
ensure_installed <- function()
if (!pkgInstalled) {
messageLog(Log,
"installing the package to build vignettes")
pkgInstalled <<- temp_install_pkg(pkgdir, libdir)
}
pkgInstalled <- build_Rd_db(pkgdir, libdir, desc)
if (file.exists("INDEX")) update_Rd_index("INDEX", "man", Log)
doc_dir <- file.path("inst", "doc")
if ("makefile" %in% dir(doc_dir)) {
messageLog(Log, "renaming 'inst/doc/makefile' to 'inst/doc/Makefile'")
file.rename(file.path(doc_dir, "makefile"),
file.path(doc_dir, "Makefile"))
}
if (vignettes &&
parse_description_field(desc, "BuildVignettes", TRUE)) {
vignette_index_path <- file.path("build", "vignette.rds")
if(file.exists(vignette_index_path))
unlink(vignette_index_path)
loadVignetteBuilder(pkgdir, TRUE)
vigns <- pkgVignettes(dir = '.', check = TRUE)
if (!is.null(vigns) && length(vigns$docs)) {
ensure_installed()
creatingLog(Log, "vignettes")
R_LIBS <- Sys.getenv("R_LIBS", NA_character_)
if (!is.na(R_LIBS)) {
on.exit(Sys.setenv(R_LIBS = R_LIBS), add = TRUE)
Sys.setenv(R_LIBS = path_and_libPath(libdir, R_LIBS))
} else {
on.exit(Sys.unsetenv("R_LIBS"), add = TRUE)
Sys.setenv(R_LIBS = libdir)
}
cmd <- file.path(R.home("bin"), "Rscript")
args <- c("--vanilla",
"--default-packages=",
"-e", shQuote("tools::buildVignettes(dir = '.', tangle = TRUE)"))
oPATH <- Sys.getenv("PATH")
Sys.setenv(PATH = paste(R.home("bin"), oPATH,
sep = .Platform$path.sep))
res <- system_with_capture(cmd, args)
Sys.setenv(PATH = oPATH)
if (res$status) {
resultLog(Log, "ERROR")
printLog0(Log, paste(c(res$stdout, ""), collapse = "\n"))
do_exit(1L)
} else {
vigns <- pkgVignettes(dir = '.', output = TRUE, source = TRUE)
stopifnot(!is.null(vigns))
resultLog(Log, "OK")
}
if (basename(vigns$dir) == "vignettes") {
dir.create(doc_dir, recursive = TRUE, showWarnings = FALSE)
tocopy <- unique(c(vigns$docs, vigns$outputs,
unlist(vigns$sources)))
copied <- file.copy(tocopy, doc_dir, copy.date = TRUE)
if (!all(copied)) {
warning(sprintf(ngettext(sum(!copied),
"%s file\n", "%s files\n"),
sQuote("inst/doc")),
strwrap(paste(sQuote(basename(tocopy[!copied])), collapse=", "),
indent = 4, exdent = 2),
"\n ignored as vignettes have been rebuilt.",
"\n Run R CMD build with --no-build-vignettes to prevent rebuilding.",
call. = FALSE)
file.copy(tocopy[!copied], doc_dir, overwrite = TRUE, copy.date = TRUE)
}
unlink(c(vigns$outputs, unlist(vigns$sources)))
extras_file <- file.path("vignettes", ".install_extras")
if (file.exists(extras_file)) {
extras <- readLines(extras_file, warn = FALSE)
if(length(extras)) {
allfiles <- dir("vignettes", all.files = TRUE,
full.names = TRUE, recursive = TRUE,
include.dirs = TRUE)
inst <- rep.int(FALSE, length(allfiles))
for (e in extras)
inst <- inst | grepl(e, allfiles, perl = TRUE,
ignore.case = TRUE)
file.copy(allfiles[inst], doc_dir, recursive = TRUE, copy.date = TRUE)
}
}
}
vignetteIndex <- .build_vignette_index(vigns)
if(NROW(vignetteIndex) > 0L) {
sources <- vignetteIndex$R
for(i in seq_along(sources)) {
file <- file.path(doc_dir, sources[i])
if (!file_test("-f", file)) next
bfr <- readLines(file, warn = FALSE)
if(all(grepl("(^
unlink(file)
vignetteIndex$R[i] <- ""
}
}
}
dir.create("build", showWarnings = FALSE)
saveRDS(vignetteIndex,
file = vignette_index_path,
version = 2L)
}
} else {
fv <- file.path("build", "vignette.rds")
if(file.exists(fv)) {
checkingLog(Log, "vignette meta-information")
db <- readRDS(fv)
pdfs <- file.path("inst", "doc", db[nzchar(db$PDF), ]$PDF)
missing <- !file.exists(pdfs)
if(any(missing)) {
msg <- c("Output(s) listed in 'build/vignette.rds' but not in package:",
strwrap(sQuote(pdfs[missing]), indent = 2L, exdent = 2L),
"Run R CMD build without --no-build-vignettes to re-create")
errorLog(Log, paste(msg, collapse = "\n"))
do_exit(1L)
} else resultLog(Log, "OK")
}
}
if (compact_vignettes != "no" &&
length(pdfs <- dir(doc_dir, pattern = "[.]pdf", recursive = TRUE,
full.names = TRUE))) {
messageLog(Log, "compacting vignettes and other PDF files")
if(compact_vignettes %in% c("gs", "gs+qpdf", "both")) {
gs_cmd <- find_gs_cmd()
gs_quality <- "ebook"
} else {
gs_cmd <- ""
gs_quality <- "none"
}
qpdf <-
if(compact_vignettes %in% c("qpdf", "gs+qpdf", "both"))
Sys.which(Sys.getenv("R_QPDF", "qpdf")) else ""
res <- compactPDF(pdfs, qpdf = qpdf,
gs_cmd = gs_cmd, gs_quality = gs_quality)
res <- format(res, diff = 1e5)
if(length(res))
printLog0(Log, paste0(" ", format(res), collapse = "\n"), "\n")
}
if (pkgInstalled) {
unlink(libdir, recursive = TRUE)
cleanup_pkg(pkgdir, Log)
}
}
cleanup_pkg <- function(pkgdir, Log)
{
owd <- setwd(pkgdir); on.exit(setwd(owd))
pkgname <- basename(pkgdir)
if (dir.exists("src")) {
setwd("src")
messageLog(Log, "cleaning src")
if (WINDOWS) {
have_make <- nzchar(Sys.which(Sys.getenv("MAKE", "make")))
if (file.exists(fn <- "Makefile.ucrt") || file.exists(fn <- "Makefile.win")) {
if (have_make)
Ssystem(Sys.getenv("MAKE", "make"), paste0("-f ", fn, " clean"))
else warning("unable to run 'make clean' in 'src'",
domain = NA)
} else {
if (file.exists(fn <- "Makevars.ucrt") || file.exists(fn <- "Makevars.win")) {
if (have_make) {
makefiles <- paste("-f",
shQuote(file.path(R.home("share"), "make", "clean.mk")),
"-f", fn)
Ssystem(Sys.getenv("MAKE", "make"),
c(makefiles, "clean"))
} else warning("unable to run 'make clean' in 'src'",
domain = NA)
}
unlink(c(Sys.glob(c("*.o", "*.so", "*.dylib", "*.mod")),
paste0(pkgname, c(".a", ".dll", ".def")),
"symbols.rds"))
if (dir.exists(".libs")) unlink(".libs", recursive = TRUE)
if (dir.exists("_libs")) unlink("_libs", recursive = TRUE)
}
} else {
makefiles <- paste("-f",
shQuote(file.path(R.home("etc"),
Sys.getenv("R_ARCH"),
"Makeconf")))
if (file.exists("Makefile")) {
makefiles <- paste(makefiles, "-f", "Makefile")
Ssystem(Sys.getenv("MAKE", "make"), c(makefiles, "clean"))
} else {
if (file.exists("Makevars")) {
makefiles <- paste(makefiles, "-f",
shQuote(file.path(R.home("share"), "make", "clean.mk")),
"-f Makevars")
Ssystem(Sys.getenv("MAKE", "make"),
c(makefiles, "clean"))
}
unlink(c(Sys.glob(c("*.o", "*.so", "*.dylib", "*.mod")),
paste0(pkgname, c(".a", ".dll", ".def")),
"symbols.rds"))
if (dir.exists(".libs")) unlink(".libs", recursive = TRUE)
if (dir.exists("_libs")) unlink("_libs", recursive = TRUE)
}
}
}
setwd(owd)
if (WINDOWS) {
has_cleanup_ucrt <- file.exists("cleanup.ucrt")
if (has_cleanup_ucrt || file.exists("cleanup.win")) {
if (nzchar(Sys.which("sh.exe"))) {
Sys.setenv(R_PACKAGE_NAME = pkgname)
Sys.setenv(R_PACKAGE_DIR = pkgdir)
Sys.setenv(R_LIBRARY_DIR = dirname(pkgdir))
if (has_cleanup_ucrt) {
messageLog(Log, "running 'cleanup.ucrt'")
Ssystem("sh", "./cleanup.ucrt")
} else {
messageLog(Log, "running 'cleanup.win'")
Ssystem("sh", "./cleanup.win")
}
}
}
} else if (file_test("-x", "cleanup")) {
Sys.setenv(R_PACKAGE_NAME = pkgname)
Sys.setenv(R_PACKAGE_DIR = pkgdir)
Sys.setenv(R_LIBRARY_DIR = dirname(pkgdir))
messageLog(Log, "running 'cleanup'")
Ssystem("./cleanup")
}
revert_install_time_patches()
}
update_Rd_index <- function(oldindex, Rd_files, Log)
{
newindex <- tempfile()
res <- tryCatch(
Rdindex(Rd_files, newindex),
error = function(e) {
errorLog(Log, "computing Rd index failed:",
conditionMessage(e))
do_exit(1L)
})
checkingLog(Log, "whether ", sQuote(oldindex), " is up-to-date")
if (file.exists(oldindex)) {
ol <- readLines(oldindex, warn = FALSE)
nl <- readLines(newindex)
if (!identical(ol, nl)) {
resultLog(Log, "NO")
if (force) {
messageLog(Log, "removing ", sQuote(oldindex),
" as '--force' was given")
unlink(oldindex)
} else {
messageLog(Log, "use '--force' to remove ",
"the existing ", sQuote(oldindex))
unlink(newindex)
}
} else {
resultLog(Log, "OK")
unlink(newindex)
}
} else {
resultLog(Log, "NO")
messageLog(Log, "creating new ", sQuote(oldindex))
file.rename(newindex, oldindex)
}
}
build_Rd_db <- function(pkgdir, libdir, desc) {
build_partial_Rd_db_path <-
file.path("build", "partial.rdb")
if(file.exists(build_partial_Rd_db_path))
unlink(build_partial_Rd_db_path)
build_refman_path <-
file.path(pkgdir, "build", paste0(basename(pkgdir), ".pdf"))
if(file.exists(build_refman_path))
unlink(build_refman_path)
db <- .build_Rd_db(pkgdir, stages = NULL,
os = c("unix", "windows"), step = 1)
if (!length(db)) return(FALSE)
names(db) <- substring(names(db),
nchar(file.path(pkgdir, "man")) + 2L)
containsSexprs <-
which(sapply(db, function(Rd) getDynamicFlags(Rd)["\\Sexpr"]))
if (!length(containsSexprs)) return(FALSE)
messageLog(Log, "installing the package to process help pages")
dir.create(libdir, mode = "0755", showWarnings = FALSE)
savelib <- .libPaths()
.libPaths(c(libdir, savelib))
on.exit(.libPaths(savelib), add = TRUE)
temp_install_pkg(pkgdir, libdir)
containsBuildSexprs <-
which(sapply(db, function(Rd) getDynamicFlags(Rd)["build"]))
if (length(containsBuildSexprs)) {
for (i in containsBuildSexprs)
db[[i]] <- prepare_Rd(db[[i]], stages = "build",
stage2 = FALSE, stage3 = FALSE)
messageLog(Log, "saving partial Rd database")
partial <- db[containsBuildSexprs]
dir.create("build", showWarnings = FALSE)
saveRDS(partial, build_partial_Rd_db_path, version = 2L)
}
needRefman <- manual &&
parse_description_field(desc, "BuildManual", TRUE) &&
any(vapply(db,
function(Rd)
any(getDynamicFlags(Rd)[c("install", "render")]),
NA))
if (needRefman) {
messageLog(Log, "building the PDF package manual")
dir.create("build", showWarnings = FALSE)
..Rd2pdf(c("--force", "--no-preview",
paste0("--output=", build_refman_path),
pkgdir), quit = FALSE)
}
return(TRUE)
}
fix_nonLF_in_files <- function(pkgname, dirPattern, Log)
{
sDir <- file.path(pkgname, c("src", "inst/include"))
files <- dir(sDir, pattern = dirPattern,
full.names = TRUE, recursive = TRUE)
for (ff in files) {
old_time <- file.mtime(ff)
lines <- readLines(ff, warn = FALSE)
writeLinesNL(lines, ff)
Sys.setFileTime(ff, old_time)
}
}
fix_nonLF_in_source_files <- function(pkgname, Log) {
fix_nonLF_in_files(pkgname, dirPattern = "\\.([cfh]|cc|cpp|hpp)$", Log)
}
fix_nonLF_in_make_files <- function(pkgname, Log) {
fix_nonLF_in_files(pkgname,
paste0("^(",
paste(c("Makefile", "Makefile.in", "Makefile.win", "Makefile.ucrt",
"Makevars", "Makevars.in", "Makevars.win", "Makevars.ucrt"),
collapse = "|"), ")$"), Log)
makes <- dir(pkgname, pattern = "^Makefile$",
full.names = TRUE, recursive = TRUE)
for (ff in makes) {
lines <- readLines(ff, warn = FALSE)
writeLinesNL(lines, ff)
}
}
fix_nonLF_in_config_files <- function(pkgname, Log) {
files <- dir(pkgname, pattern = "^(configure|cleanup)$",
full.names = TRUE, recursive = TRUE)
for (ff in files) {
lines <- readLines(ff, warn = FALSE)
writeLinesNL(lines, ff)
}
}
find_empty_dirs <- function(d)
{
files <- dir(d, all.files = TRUE, full.names = TRUE)
for (dd in files[dir.exists(files)]) {
if (grepl("/\\.+$", dd)) next
find_empty_dirs(dd)
}
keep_empty1 <- parse_description_field(desc, "BuildKeepEmpty",
keep_empty)
if (!keep_empty1)
files <- dir(d, all.files = TRUE, full.names = TRUE)
if (length(files) <= 2L) {
if (keep_empty1) {
printLog(Log, "WARNING: directory ", sQuote(d), " is empty\n")
} else {
unlink(d, recursive = TRUE)
printLog(Log, "Removed empty directory ", sQuote(d), "\n")
}
}
}
fixup_R_dep <- function(pkgname, ver = "2.10")
{
desc <- .read_description(file.path(pkgname, "DESCRIPTION"))
Rdeps <- .split_description(desc)$Rdepends2
for(dep in Rdeps) {
if(dep$op != '>=') next
if(dep$version >= package_version(ver)) return()
}
flatten <- function(x) {
if(length(x) == 3L)
paste0(x$name, " (", x$op, " ", x$version, ")")
else x[[1L]]
}
deps <- desc["Depends"]
desc["Depends"] <- if(!is.na(deps)) {
deps <- .split_dependencies(deps)
deps <- deps[names(deps) != "R"]
paste(c(sprintf("R (>= %s)", ver), sapply(deps, flatten)),
collapse = ", ")
} else sprintf("R (>= %s)", ver)
.write_description(desc, file.path(pkgname, "DESCRIPTION"))
printLog(Log,
" NB: this package now depends on R (>= ", ver, ")\n")
}
resave_data_rda <- function(pkgname, resave_data)
{
if (resave_data == "no") return()
ddir <- file.path(pkgname, "data")
if(resave_data == "best") {
files <- Sys.glob(c(file.path(ddir, "*.rda"),
file.path(ddir, "*.RData"),
file.path(pkgname, "R", "sysdata.rda")))
messageLog(Log, "re-saving image files")
resaveRdaFiles(files)
rdas <- checkRdaFiles(files)
if(any(rdas$compress %in% c("bzip2", "xz")))
fixup_R_dep(pkgname, "2.10")
} else {
rdas <- checkRdaFiles(Sys.glob(c(file.path(ddir, "*.rda"),
file.path(ddir, "*.RData"))))
if(nrow(rdas)) {
update <- with(rdas, ASCII | compress == "none" | version < 2)
if(any(update)) {
messageLog(Log, "re-saving image files")
resaveRdaFiles(row.names(rdas)[update], "gzip")
}
}
if(file.exists(f <- file.path(pkgname, "R", "sysdata.rda"))) {
rdas <- checkRdaFiles(f)
update <- with(rdas, ASCII | compress == "none" | version < 2)
if(any(update)) {
messageLog(Log, "re-saving sysdata.rda")
resaveRdaFiles(f, "gzip")
}
}
}
}
resave_data_others <- function(pkgname, resave_data)
{
if (resave_data == "no") return()
if(!dir.exists(ddir <- file.path(pkgname, "data")))
return()
ddir <- normalizePath(ddir)
dataFiles <- filtergrep("\\.(rda|RData)$",
list_files_with_type(ddir, "data"))
if (!length(dataFiles)) return()
resaved <- character()
on.exit(unlink(resaved))
Rs <- grep("\\.[Rr]$", dataFiles, value = TRUE)
if (length(Rs)) {
messageLog(Log, "re-saving .R files as .rda")
lapply(Rs, function(x){
envir <- new.env(hash = TRUE)
sys.source(x, chdir = TRUE, envir = envir)
save(list = ls(envir, all.names = TRUE),
file = sub("\\.[Rr]$", ".rda", x),
compress = TRUE, compression_level = 9,
envir = envir,
version = 2L)
resaved <<- c(resaved, x)
})
printLog(Log,
" NB: *.R converted to .rda: other files may need to be removed\n")
}
tabs <- grep("\\.(CSV|csv|TXT|tab|txt)$", dataFiles, value = TRUE)
if (length(tabs)) {
messageLog(Log, "re-saving tabular files")
if (resave_data == "gzip") {
lapply(tabs, function(nm) {
x <- readLines(nm, warn = FALSE)
con <- gzfile(paste0(nm, ".gz"), "wb")
writeLines(x, con)
close(con)
resaved <<- c(resaved, nm)
})
} else {
OK <- TRUE
lapply(tabs, function(nm) {
x <- readLines(nm, warn = FALSE)
nm3 <- paste(nm, c("gz", "bz2", "xz"), sep = ".")
con <- gzfile(nm3[1L], "wb", compression = 9L); writeLines(x, con); close(con)
con <- bzfile(nm3[2L], "wb", compression = 9L); writeLines(x, con); close(con)
con <- xzfile(nm3[3L], "wb", compression = 9L); writeLines(x, con); close(con)
sizes <- file.size(nm3) * c(0.9, 1, 1)
ind <- which.min(sizes)
if(ind > 1) OK <<- FALSE
resaved <<- c(resaved, nm, nm3[-ind])
})
if (!OK) fixup_R_dep(pkgname, "2.10")
}
}
}
force <- FALSE
vignettes <- TRUE
manual <- TRUE
with_md5 <- FALSE
with_log <- FALSE
pkgs <- character()
options(showErrorCalls = FALSE, warn = 1)
Renv <- Sys.getenv("R_BUILD_ENVIRON", unset = NA_character_)
if(!is.na(Renv)) {
if(nzchar(Renv) && file.exists(Renv)) readRenviron(Renv)
} else {
rarch <- .Platform$r_arch
if (nzchar(rarch) &&
file.exists(Renv <- paste0("~/.R/build.Renviron.", rarch)))
readRenviron(Renv)
else if (file.exists(Renv <- "~/.R/build.Renviron"))
readRenviron(Renv)
}
compact_vignettes <- Sys.getenv("_R_BUILD_COMPACT_VIGNETTES_", "no")
resave_data <- Sys.getenv("_R_BUILD_RESAVE_DATA_", "gzip")
keep_empty <-
config_val_to_logical(Sys.getenv("_R_BUILD_KEEP_EMPTY_DIRS_", "FALSE"))
install_dependencies <- Sys.getenv("_R_BUILD_INSTALL_DEPENDENCIES_")
if(nzchar(install_dependencies) &&
(install_dependencies %notin% c("strong", "most", "all")))
install_dependencies <-
if(config_val_to_logical(install_dependencies)) "most" else ""
if (is.null(args)) {
args <- commandArgs(TRUE)
args <- paste(args, collapse = " ")
args <- strsplit(args,'nextArg', fixed = TRUE)[[1L]][-1L]
}
compression <- "gzip"
while(length(args)) {
a <- args[1L]
if (a %in% c("-h", "--help")) {
Usage()
do_exit(0L)
}
else if (a %in% c("-v", "--version")) {
cat("R add-on package builder: ",
R.version[["major"]], ".", R.version[["minor"]],
" (r", R.version[["svn rev"]], ")\n", sep = "")
cat("",
.R_copyright_msg(1997),
"This is free software; see the GNU General Public License version 2",
"or later for copying conditions. There is NO warranty.",
sep = "\n")
do_exit(0L)
} else if (a == "--force") {
force <- TRUE
} else if (a == "--keep-empty-dirs") {
keep_empty <- TRUE
} else if (a == "--no-build-vignettes") {
vignettes <- FALSE
} else if (a == "--no-vignettes") {
stop("'--no-vignettes' is defunct:\n use '--no-build-vignettes' instead",
call. = FALSE, domain = NA)
} else if (a == "--resave-data") {
resave_data <- "best"
} else if (a == "--no-resave-data") {
resave_data <- "no"
} else if (substr(a, 1, 14) == "--resave-data=") {
resave_data <- substr(a, 15, 1000)
} else if (a == "--no-manual") {
manual <- FALSE
} else if (substr(a, 1, 20) == "--compact-vignettes=") {
compact_vignettes <- substr(a, 21, 1000)
} else if (a == "--compact-vignettes") {
compact_vignettes <- "qpdf"
} else if (a == "--md5") {
with_md5 <- TRUE
} else if (a == "--log") {
with_log <- TRUE
} else if (substr(a, 1, 23) == "--install-dependencies=") {
install_dependencies <- substr(a, 24, 1000)
} else if (a == "--install-dependencies") {
install_dependencies <- "most"
} else if (substr(a, 1, 14) == "--compression=") {
compression <- match.arg(substr(a, 15, 1000),
c("none", "gzip", "bzip2", "xz"))
} else if (startsWith(a, "-")) {
message("Warning: unknown option ", sQuote(a))
} else pkgs <- c(pkgs, a)
args <- args[-1L]
}
if(compact_vignettes %notin% c("no", "qpdf", "gs", "gs+qpdf", "both")) {
warning(gettextf("invalid value for '--compact-vignettes', assuming %s",
"\"qpdf\""),
domain = NA)
compact_vignettes <-"qpdf"
}
Sys.unsetenv("R_DEFAULT_PACKAGES")
startdir <- getwd()
if (is.null(startdir))
stop("current working directory cannot be ascertained")
if (WINDOWS) {
rhome <- chartr("\\", "/", R.home())
Sys.setenv(R_HOME = rhome)
}
for(pkg in pkgs) {
pkg <- sub("/$", "", pkg)
Log <- if(with_log)
newLog(paste0(file.path(startdir, basename(pkg)),
"-00build.log"))
else
newLog()
setwd(startdir)
res <- tryCatch(setwd(pkg), error = function(e) {
errorLog(Log, "cannot change to directory ", sQuote(pkg))
do_exit(1L)
})
pkgdir <- getwd()
pkgname <- basename(pkgdir)
checkingLog(Log, "for file ", sQuote(file.path(pkg, "DESCRIPTION")))
f <- file.path(pkgdir, "DESCRIPTION")
if (file.exists(f)) {
desc <- try(.read_description(f))
if (inherits(desc, "try-error") || !length(desc)) {
resultLog(Log, "EXISTS but not correct format")
do_exit(1L)
}
resultLog(Log, "OK")
} else {
resultLog(Log, "NO")
do_exit(1L)
}
if(is.na(intname <- desc["Package"]) || !length(intname) ||
!nzchar(intname)) {
errorLog(Log, "invalid 'Package' field"); do_exit(1L)
}
setwd(dirname(pkgdir))
filename <- paste0(intname, "_", desc["Version"], ".tar")
filepath <- file.path(startdir, filename)
Tdir <- tempfile("Rbuild")
dir.create(Tdir, mode = "0755")
if (WINDOWS) {
if (!file.copy(pkgname, Tdir, recursive = TRUE, copy.date = TRUE)) {
errorLog(Log, "copying to build directory failed")
do_exit(1L)
}
} else {
ver <- suppressWarnings(system2("cp", "--version", stdout = TRUE,
stderr = FALSE))
GNU_cp <- any(grepl("GNU coreutils", ver))
cp_sw <- if(GNU_cp) "-LR --preserve=timestamps" else "-pLR"
if (system2("cp", c(cp_sw, shQuote(pkgname), shQuote(Tdir)))) {
errorLog(Log, "copying to build directory failed")
do_exit(1L)
}
}
setwd(Tdir)
if (pkgname != intname) {
if (!file.rename(pkgname, intname)) {
message(gettextf("Error: cannot rename directory to %s",
sQuote(intname)), domain = NA)
do_exit(1L)
}
pkgname <- intname
}
messageLog(Log, "preparing ", sQuote(pkgname), ":")
prepare_pkg(normalizePath(pkgname, "/"), desc, Log);
owd <- setwd(pkgname)
allfiles <- dir(".", all.files = TRUE, recursive = TRUE,
full.names = TRUE, include.dirs = TRUE)
allfiles <- substring(allfiles, 3L)
bases <- basename(allfiles)
exclude <- inRbuildignore(allfiles, pkgdir)
isdir <- dir.exists(allfiles)
exclude <- exclude | (isdir & (bases %in%
c("check", "chm", .vc_dir_names)))
exclude <- exclude | (isdir & grepl("([Oo]ld|\\.Rcheck)$", bases))
exclude <- exclude | bases %in% c("Read-and-delete-me", "GNUMakefile")
exclude <- exclude | startsWith(bases, "._")
exclude <- exclude | (isdir & grepl("^src.*/[.]deps$", allfiles))
exclude <- exclude | (allfiles == paste0("src/", pkgname, "_res.rc"))
exclude <- exclude | endsWith(allfiles, "inst/doc/.Rinstignore") |
endsWith(allfiles, "inst/doc/.build.timestamp") |
endsWith(allfiles, "vignettes/.Rinstignore")
exclude <- exclude | grepl("^.Rbuildindex[.]", allfiles)
exclude <- exclude | (bases %in% .hidden_file_exclusions)
exts <- "\\.(tar\\.gz|tar|tar\\.bz2|tar\\.xz|tgz|zip)"
exclude <- exclude | grepl(paste0("^", pkgname, "_[0-9.-]+", exts, "$"),
allfiles)
unlink(allfiles[exclude], recursive = TRUE, force = TRUE,
expand = FALSE)
setwd(owd)
res <- .check_package_subdirs(pkgname, TRUE)
if (any(lengths(res))) {
messageLog(Log, "excluding invalid files")
print(res)
}
setwd(Tdir)
if (!WINDOWS) .Call(C_dirchmod, pkgname, group.writable=FALSE)
add_build_stamp_to_description_file(file.path(pkgname, "DESCRIPTION"),
pkgdir)
add_expanded_R_fields_to_description_file(file.path(pkgname,
"DESCRIPTION"))
messageLog(Log,
"checking for LF line-endings in source and make files and shell scripts")
fix_nonLF_in_source_files(pkgname, Log)
fix_nonLF_in_make_files(pkgname, Log)
fix_nonLF_in_config_files(pkgname, Log)
messageLog(Log, "checking for empty or unneeded directories");
find_empty_dirs(pkgname)
for(dir in c("Meta", "R-ex", "chtml", "help", "html", "latex")) {
d <- file.path(pkgname, dir)
if (dir.exists(d)) {
msg <- paste("WARNING: Removing directory",
sQuote(d),
"which should only occur",
"in an installed package")
printLog(Log, paste(strwrap(msg, indent = 0L, exdent = 2L),
collapse = "\n"), "\n")
unlink(d, recursive = TRUE)
}
}
unlink(file.path(pkgname,
c("src-i386", "src-x64", "src-x86_64", "src-ppc")),
recursive = TRUE)
if(dir.exists(file.path(pkgname, "data")) ||
file_test("-f", file.path(pkgname, "R", "sysdata.rda"))) {
if(!str_parse_logic(desc["LazyData"], FALSE)) {
messageLog(Log,
"looking to see if a 'data/datalist' file should be added")
tryCatch(add_datalist(pkgname),
error = function(e)
printLog(Log, " unable to create a 'datalist' file: may need the package to be installed\n"))
}
resave_data1 <- parse_description_field(desc, "BuildResaveData",
resave_data, logical=FALSE)
resave_data_others(pkgname, resave_data1)
resave_data_rda(pkgname, resave_data1)
}
if (!dir.exists(file.path(pkgname, "data"))) {
desc <- file.path(pkgname, "DESCRIPTION")
db <- .read_description(desc)
ndb <- names(db)
omit <- character()
for (x in c("LazyData", "LazyDataCompression"))
if (x %in% ndb) omit <- c(omit, x)
if (length(omit)) {
printLog(Log,
sprintf("Omitted %s from DESCRIPTION\n",
paste(sQuote(omit), collapse = " and ")))
db <- db[!(names(db) %in% omit)]
.write_description(db, desc)
}
}
desc <- .read_description(file.path(pkgname, "DESCRIPTION"))
Rdeps <- .split_description(desc)$Rdepends2
hasDep350 <- FALSE
for(dep in Rdeps) {
if(dep$op != '>=') next
if(dep$version >= "3.5.0") hasDep350 <- TRUE
}
if (!hasDep350) {
allfiles <- dir(".", all.files = TRUE, recursive = TRUE,
full.names = TRUE)
allfiles <- substring(allfiles, 3L)
vers <- get_serialization_version(allfiles)
toonew <- names(vers[vers >= 3L])
if (length(toonew)) {
fixup_R_dep(pkgname, "3.5.0")
msg <- paste("WARNING: Added dependency on R >= 3.5.0 because",
"serialized objects in serialize/load version 3",
"cannot be read in older versions of R. File(s)",
"containing such objects:")
printLog(Log,
paste(c(strwrap(msg, indent = 2L, exdent = 2L),
paste0(" ", .pretty_format(sort(toonew)))),
collapse = "\n"),
"\n")
}
}
if(!file.exists(namespace <- file.path(pkgname, "NAMESPACE")) ) {
messageLog(Log, "creating default NAMESPACE file")
writeDefaultNamespace(namespace)
}
if(with_md5) {
messageLog(Log, "adding MD5 file")
.installMD5sums(pkgname)
} else {
unlink(file.path(pkgname, "MD5"))
}
ext <- switch(compression,
"none"="", "gzip"= ".gz", "bzip2" = ".bz2", "xz" = ".xz")
filename <- paste0(pkgname, "_", desc["Version"], ".tar", ext)
filepath <- file.path(startdir, filename)
messageLog(Log, "building ", sQuote(filename))
res <- utils::tar(filepath, pkgname, compression = compression,
compression_level = 9L,
tar = Sys.getenv("R_BUILD_TAR"),
extra_flags = NULL)
if (res) {
errorLog(Log, "packaging into tarball failed")
do_exit(1L)
}
message("")
setwd(startdir)
unlink(Tdir, recursive = TRUE)
closeLog(Log)
}
do_exit(0L)
} |
RcppKmomentEST = function(k,a,b,mu,Sigma,lambda,tau,nu)
{
p = length(mu)
tautil<-tau/sqrt(1+sum(lambda^2))
if(pt(tautil,nu) < pnorm(-37)){
Delta = sqrtm(Sigma)%*%lambda/sqrt(1+sum(lambda^2))
Gamma = Sigma - Delta%*%t(Delta)
rownames(Gamma) <- colnames(Gamma)
omega_tau = (nu+tautil^2)/(nu+1)
return(RcppKmomentT(k = k,a = a, b = b,mu = mu - tautil*Delta,Sigma = omega_tau*Gamma,nu=nu+1))
}
SS = sqrtm(Sigma)
varpsi = lambda/sqrt(1+sum(lambda^2))
Omega = cbind(rbind(Sigma,-t(varpsi)%*%SS),rbind(-SS%*%varpsi,1))
rownames(Omega) <- colnames(Omega)
return(RcppKmomentT(k = k,a = c(a,-10^7),b = c(b,tautil),mu = c(mu,0),Sigma = Omega,nu = nu)[,-(p+1)])
} |
map.bubble <-
function(shapedir= "WorkingDir",shapename,boundary.label,spe.vector=NULL,cex=0.8,col="lightblue",bubcex,bubpch=1,bublwd=2,bubcol="green"){
if(is.character(shapename)==FALSE | length(shapename)>1){
stop("shapename must be a character input of length 1")
}
if(shapedir == "WorkingDir"){
ogrListLayers(paste(shapename,".shp",sep=""))
shape <- readOGR(paste(shapename,".shp",sep=""), layer=shapename)
}else{
ogrListLayers(shapedir)
shape <- readOGR(dsn = shapedir, layer=shapename)
}
if(!is.null(spe.vector)){
if(is.null(boundary.label)){ stop("boundary.label must specify") }
if(length(col)==1){
members <- rep(0,nrow(shape))
members[match(spe.vector,shape[[boundary.label]])]=1
mycol <- ifelse(members==1,col,"white")
plot(shape,col=mycol)
points(getSpPPolygonsLabptSlots(shape),col=bubcol,pch=bubpch,lwd=bublwd,cex=bubcex)
invisible(text(getSpPPolygonsLabptSlots(shape),labels=as.character(shape[[boundary.label]]), cex=cex))
}else{
mycol <- rep("white",nrow(shape))
mycol[match(spe.vector,shape[[boundary.label]])] <- col
plot(shape,col=mycol)
points(getSpPPolygonsLabptSlots(shape),col=bubcol,pch=bubpch,lwd=bublwd,cex=bubcex)
invisible(text(getSpPPolygonsLabptSlots(shape),labels=as.character(shape[[boundary.label]]), cex=cex))
}
}else{
if(length(col)>1) {stop("spe.vector must specify for different color levels") }
plot(shape)
points(getSpPPolygonsLabptSlots(shape),col=bubcol,pch=bubpch,lwd=bublwd,cex=bubcex)
if(!is.null(boundary.label)){
invisible(text(getSpPPolygonsLabptSlots(shape),labels=as.character(shape[[boundary.label]]), cex=cex))
}
}} |
rm_numdiff_discrete_differences <- function(ll0, ll1, ll2, h)
{
d1 <- ( ll1 - ll2 ) / ( 2 * h )
d2 <- ( ll1 + ll2 - 2*ll0 ) / h^2
res <- list(d1=d1, d2=d2)
return(res)
} |
NULL
dDPH <- function(x, obj){
if (class(obj) == 'disc_phase_type') {
if (sum(x %% 1 > 0) > 0){
stop('x should only contain integers.')
}
e <- matrix(1, nrow = nrow(obj$subint_mat))
t <- e - obj$subint_mat %*% e
dens_vec <- c()
for(i in x){
if (i == 0) {
dens_vec <- c(dens_vec, obj$defect)
} else {
dens_vec <- c(dens_vec, obj$init_probs %*% (obj$subint_mat %^% (i-1))
%*% t)
}
}
return(dens_vec)
} else {
stop("Please provide an object of class 'disc_phase_type'.")
}
}
qDPH <- function(p, obj){
vec <- c()
inv <- function(y) uniroot(function(q) pDPH(q, obj)-y, c(0,400))$root[1]
if (class(obj) == 'disc_phase_type') {
for (i in p) {
vec <- c(vec, round(inv(i)))
}
} else {
stop("Please provide an object of class 'disc_phase_type'.")
}
return(vec)
}
pDPH <- function(q, obj){
if (class(obj) == 'disc_phase_type') {
e <- matrix(1, nrow = nrow(obj$subint_mat))
prob_vec <- c()
for(i in q){
prob_vec <- c(prob_vec, 1 - obj$init_probs %*% (obj$subint_mat %^% i)
%*% e)
}
return(prob_vec)
} else {
stop("Please provide an object of class 'disc_phase_type'.")
}
}
rDPH <- function(n, obj){
if (class(obj) == 'disc_phase_type') {
if (length(n) > 1){
n <- length(n)
}
subint_mat <- obj$subint_mat
init_probs <- c(obj$init_probs, obj$defect)
p <- nrow(subint_mat)
n_vec <- numeric(n)
int_mat <- cbind(subint_mat, 1 - rowSums(subint_mat))
for (i in 1:n) {
j <- sample(p + 1, 1, prob = init_probs)
while (j != (p + 1)) {
n_vec[i] <- n_vec[i] + 1
j <- sample(p + 1, 1, prob = int_mat[j,])
}
}
return(n_vec)
} else {
stop("Please provide an object of class 'disc_phase_type'.")
}
}
rFullDPH <- function(obj){
if (!(class(obj) == 'disc_phase_type')){
stop("Please provide an object of class 'disc_phase_type'.")
}
init_probs <- obj$init_probs
n <- length(init_probs)
subint_mat <- obj$subint_mat
exit_rate <- 1 - t(t(rowSums(subint_mat)))
int_mat <- cbind(subint_mat, exit_rate)
states <- 1:(n+1)
curstate <- sample(1:n, 1, prob = init_probs)
states <- curstate
times <- NULL
curtime <- 1
while(curstate <= n){
curstate <- sample(1:(n+1), 1, prob = int_mat[curstate,])
if (curstate == states[length(states)]){
curtime <- curtime + 1
} else {
times <- c(times, curtime)
states <- c(states, curstate)
curtime <- 1
}
}
return(data.frame(state = states[-length(states)], time = times))
} |
companion <- function(object, ...) {UseMethod("companion", object)}
companion.default <- function(object, ...) {
stop("No methods for class ",
paste0(class(object), collapse = " / "), " found.")
}
companion.bvar <- function(
object,
type = c("quantile", "mean"),
conf_bands = 0.5,
...) {
type <- match.arg(type)
K <- object[["meta"]][["K"]]
M <- object[["meta"]][["M"]]
lags <- object[["meta"]][["lags"]]
vars <- name_deps(object[["variables"]], M = M)
vars_expl <- name_expl(vars, M = M, lags = lags)[-1]
vars_dep <- c(vars, if(lags > 1) {rep("lag", M * (lags - 1))})
if(type == "quantile") {
quantiles <- quantile_check(conf_bands)
coefs <- apply(object[["beta"]], c(2, 3), quantile, quantiles)
} else {
quantiles <- 0.5
coefs <- apply(object[["beta"]], c(2, 3), mean)
}
if(length(quantiles) == 1) {
comp <- get_beta_comp(coefs, K, M, lags)
dimnames(comp) <- list(vars_dep, vars_expl)
} else {
comp <- array(NA, c(length(quantiles), K - 1, K - 1))
for(i in 1:length(quantiles)) {
comp[i, , ] <- get_beta_comp(coefs[i, , ], K, M, lags)
}
dimnames(comp)[[1]] <- dimnames(coefs)[[1]]
dimnames(comp)[[2]] <- vars_dep
dimnames(comp)[[3]] <- vars_expl
}
class(comp) <- append("bvar_comp", class(comp))
return(comp)
}
print.bvar_comp <- function(x, digits = 3L, complete = FALSE, ...) {
.print_coefs(x, digits, type = "companion", complete = complete, ...)
return(invisible(x))
} |
`SHOWTOMO` <-
function(MOD, colmap=topo.colors(100), zlim=NULL, MAP=NULL, I=1, J=2, bkgr="white" ,
linelty=1, linelwd=1, ptpch=".", ptcex=1 )
{
if(missing(colmap)) { colmap=tomo.colors(100) }
if(missing(MAP)) { MAP=NULL }
if(missing(I)) { I=1 }
if(missing(J)) { J=length(MOD$MOD) }
if(missing(zlim)) { zlim=NULL }
if(missing(bkgr)) { bkgr="white" }
opar = par(no.readonly = TRUE)
NTOT = (J-I+1)
KROW = floor(NTOT/5)
if(KROW>=1)
{
par(mfrow=c(KROW,5),mai=c(0, 0, 0,0))
}
else
{
par(mfrow=c(1, NTOT),mai=c(0, 0, 0,0))
}
KMAX = min(c(J, 25))
for( i in I:KMAX)
{
pltomo(MOD$x,MOD$y,MOD$MOD,i, colmap=colmap, zlim=zlim, bkgr= bkgr )
text(MOD$x[1],MOD$y[1], labels=paste(sep=" : ", paste(sep="", "LAY=", i) , paste(sep="", "Z=",MOD$D[i])), adj=c(0,0) ,xpd=TRUE, font=2)
box()
if(!is.null(MAP)) GEOmap::plotGEOmapXY(MAP, PROJ=MAP$PROJ, add=TRUE, xpd=FALSE, linelty=linelty, linelwd=linelwd, ptpch=ptpch, ptcex=ptcex )
}
newpar= par(no.readonly = TRUE)
par(opar)
invisible(newpar)
} |
EEB.conRej <-
function(beta,nu,delta=0,S=1,alpha=0.05,tol=1e-4,max.itr=5000)
{
tv<-qt(1-alpha,df=nu)
if(delta==0)
{
return(S*(qt(1-(alpha*(1-beta)/2),df=nu)+tv))
}else
{
a<-S*(tv+qt(1-alpha/2,df=nu))
b<-100
s<-0
while(s<max.itr)
{
c<-(a+b)/2
diff<-(b-a)/2
g<-pB.conRej(c,nu=nu,delta=delta,S=S,alpha=alpha)-beta
if(abs(g)<tol|diff<tol)
{
break
}else
{
if(g<0)
{
a<-c
}else
{
b<-c
}
s<-s+1
}
}
return(c)
}
} |
dfgps <-
function(X,y,penalty="enet", ex_para=c(0), STEP=10000, STEP.max=100000, DFtype="MODIFIED", p.max=300){
candidate <- c("enet","genet","alasso")
if(sum(candidate == penalty) != 1) stop('penalty must equal "enet", "genet" or "alasso".')
if(mode(X)!="numeric") stop(" X must be numeric.")
if(!is.matrix(X)) stop(" X must be a matrix.")
if(mode(y)!="numeric") stop(" y must be numeric.")
if (!is.vector(y)) stop("y must be a vector.")
if (nrow(X)!=length(y)) stop("The number of sample must not be differenet between X and y.")
if (sum(complete.cases(X)==FALSE)>0) stop("X must be complete data.")
if (sum(complete.cases(y)==FALSE)>0) stop("y must be complete data.")
penalty_int <- which(candidate == penalty)
penalty_int <- as.integer(penalty_int - 1)
if((penalty_int==0 || penalty_int==1) && length(ex_para)!=1) stop('"ex_para" must be a scalar.')
if(!is.numeric(ex_para)) stop('"ex_para" must be a numeric.')
if(penalty_int==0 && (ex_para < 0 || ex_para >=1)) stop('"ex_para" must be in [0,1).')
if(penalty_int==1 && (ex_para <= 0 || ex_para >=1)) stop('"ex_para" must be in (0,1).')
if(penalty_int==2 && length(ex_para)!=2) stop("ex_para must be a 2-dimensional vector.")
if(penalty_int==2 && length(ex_para)!=2) stop("ex_para must be a 2-dimensional vector.")
if(penalty_int==2 && ex_para[1]<0 ) stop("ex_para[1] must be non-negative.")
if(penalty_int==2 && ex_para[2]<0 ) stop("ex_para[2] must be non-negative.")
if(mode(STEP)!="numeric") stop('"STEP" must be numeric.')
if(STEP < 500) stop('"STEP" must be greater than or equal to 500.')
if(STEP >= 1e+8) stop('"STEP" must be less than 1e+8.')
candidate_DFtype <- c("NAIVE","MODIFIED")
if(sum(candidate_DFtype == DFtype) != 1) stop('DFtype must be "MODIFIED" or "NAIVE".')
if(mode(STEP)!="numeric") stop('"STEP" must be numeric.')
if(p.max < 1) stop('"p.max" must bea positive integer.')
if(p.max >= 10000) stop('"p.max" must be less than 10000.')
if(mode(STEP.max)!="numeric") stop('"STEP.max" must be numeric.')
if(STEP.max< 500) stop('"STEP.max" must be greater than or equal to 500.')
if(STEP.max >= 1e+8) stop('"STEP.max" must be less than 1e+8.')
if(penalty_int==2){
if(ncol(X) < nrow(X)) PLS <- solve(t(X)%*%X + ex_para[2]*diag(ncol(X)))%*%t(X)%*%y
if(ncol(X) >= nrow(X)) PLS <- t(X)%*%solve((X)%*%t(X) + ex_para[2]*diag(nrow(X)))%*%y
weight_vec <- (abs(PLS))^(-ex_para[1])
}else{
weight_vec <- rep(1,ncol(X))
}
meanX <- apply(X,2,mean)
meanX_mat <- sweep(X, 2, meanX)
standardize_vec <- 1 / sqrt(apply(meanX_mat^2,2,sum))
standardize_vec[standardize_vec==Inf] <- 0
standardize_mat <- matrix(rep(standardize_vec,nrow(X)),nrow(X),ncol(X),byrow=T)
meany <- mean(y)
X0 <- X
X <- meanX_mat * standardize_mat
y0 <- y
y <- y-meany
if( nrow(X) <= ncol(X)){
beta_OLS <- t(X)%*%solve(X%*%t(X) + 0.001*diag(nrow(X)))%*%y
}else if(det(t(X)%*%X) < 1e-3){
beta_OLS <- solve(t(X)%*%X + 0.001*diag(ncol(X))) %*%t(X)%*%y
}else{
beta_OLS <- solve(t(X)%*%X)%*%t(X)%*%y
}
delta_t <- sum(abs(beta_OLS)) / STEP
STEP.max=as.integer(STEP.max)
p.max=as.integer(p.max)
N <- length(y)
gps_C=.Call("gps", X,y,delta_t,penalty_int,ex_para, STEP.max,p.max,weight_vec,standardize_vec)
betagps_matrix <- gps_C[1][[1]]
STEP_adj <- gps_C[2][[1]]
RSS <- gps_C[3][[1]]
increment_covpenalty_vec_power <- gps_C[4][[1]]
selected_variable_index_vec <- gps_C[5][[1]]
betahat_index_vec_adj <- gps_C[6][[1]]
tuning <- gps_C[7][[1]]
tuning_stand <- gps_C[8][[1]]
selected_variable_index_vec <- selected_variable_index_vec[selected_variable_index_vec>0]
betagps_matrix <- betagps_matrix[1:STEP_adj]
RSS <- RSS[1:STEP_adj]
increment_covpenalty_vec_power <- increment_covpenalty_vec_power[1:STEP_adj]
betahat_index_vec_adj <- betahat_index_vec_adj[1:STEP_adj]
tuning <- tuning[1:STEP_adj]
tuning_stand <- tuning_stand[1:STEP_adj]
ex_X_selected = X[,selected_variable_index_vec]
betagps_matrix=as.integer(betagps_matrix)
STEP_adj2=as.integer(STEP_adj-1)
STEP_adj=as.integer(STEP_adj)
betahat_index_vec_adj = as.integer(betahat_index_vec_adj)
selected_variable_index_vec = as.integer(selected_variable_index_vec)
increment_covpenalty_vec0 <- (1-2*delta_t/N)^ increment_covpenalty_vec_power
increment_covpenalty_vec1 <- 1-(1-2*delta_t/N)^ increment_covpenalty_vec_power
t0 <- log( 1-2*delta_t/N*increment_covpenalty_vec_power ) / log(1-2*delta_t/N)
increment_covpenalty_vec2 <- 1-(1-2*delta_t/N)^ t0
increment_covpenalty_vec3 <- 2*delta_t/N * increment_covpenalty_vec_power
if(DFtype=="NAIVE"){
dfgps_vec=.Call("DFNAIVE2", ex_X_selected,y,betahat_index_vec_adj,STEP_adj2,increment_covpenalty_vec3)
if(sum( abs(dfgps_vec)>1e+10 | is.na(dfgps_vec) | dfgps_vec<0 ) > 1 ) stop("DF is not correct")
}else if(DFtype=="MODIFIED"){
qr_X <- qr(ex_X_selected)
qr_X_R <- qr.R(qr_X)
qr_X_R[is.nan(qr_X_R)] <- 0
dfgps_vec=.Call("DFMODIFIED2", qr_X_R, y, betahat_index_vec_adj, STEP_adj2, increment_covpenalty_vec3, selected_variable_index_vec)
if(sum( abs(dfgps_vec)>1e+10 | is.na(dfgps_vec) | dfgps_vec<0 ) > 1 ) stop("DF is not correct")
}
p<-ncol(X)
N<-nrow(X)
if(DFtype=="NAIVE" || DFtype=="MODIFIED" || DFtype=="MODIFIED2"){
ans <- list(N=N,p=p,delta_t=delta_t,coefficient_index=betagps_matrix,df=dfgps_vec,STEP_adj=STEP_adj2,RSS=RSS,tuning=tuning,tuning_stand=tuning_stand,X=X0,y=y0,ex_para=ex_para,beta_OLS=beta_OLS,Xstand=X,ystand=y)
}else{
ans <- list(N=N,p=p,delta_t=delta_t,coefficient_index=betagps_matrix,STEP_adj=STEP_adj2,RSS=RSS,tuning=tuning,tuning_stand=tuning_stand,X=X0,y=y0,ex_para=ex_para,beta_OLS=beta_OLS,Xstand=X,ystand=y)
}
class(ans) <- "dfgps"
return(invisible(ans))
} |
model{
for (i in 1:n) {
weight[i] ~ dnorm(mu[i], tau.within)
mu[i] <- b0 + b1[breed[i]]
}
for (j in 2:n.breeds) {
b1[j] ~ dnorm(0, tau.between)
}
b0 ~ dnorm(0, 1e-06)
b1[1] <- 0
tau.within <- sd.within^-0.5
tau.between <- sd.between^-0.5
sd.within ~ dunif(0, 10)
sd.between ~ dunif(0, 10)
} |
ggplot2::ggplot(datasets::airquality) +
ggplot2::geom_line(stat = "identity", ggplot2::aes(x = lubridate::make_date(lubridate::year(lubridate::today()), Month, Day), y = Wind)) + |
context("decrypt")
test_that("decryption works", {
path <- ifelse(dir.exists("sample-captchas/"), "sample-captchas/",
"./tests/testthat/sample-captchas/")
path2 <- ifelse(dir.exists("sample-captchas/"), "./sample-model.hdf5",
"./tests/testthat/sample-model.hdf5")
files <- list.files(path, pattern = "_", full.names = TRUE)
model <- load_model(path2)
cap <- read_captcha(files)
expect_equal(class(decrypt(files, model)), "character")
expect_equal(class(decrypt(files, path2)), "character")
expect_equal(class(decrypt(files, "rfb")), "character")
expect_equal(class(decrypt(cap, model)), "character")
expect_equal(class(decrypt(cap, path2)), "character")
expect_equal(class(decrypt(cap, "rfb")), "character")
})
test_that("decrypt works with raw vector", {
path <- ifelse(dir.exists("sample-captchas/"), "sample-captchas/",
"./tests/testthat/sample-captchas/")
captcha_raw <- readr::read_file_raw(paste0(path, "captcha372a5114848de_f9ccnk.png"))
expect_equal(class(decrypt(captcha_raw, "rfb")), "character")
}) |
UmxBestMatchesFromIsland <- function(Umatrix, BestMatches, Imx, Cls= NULL, Toroid=T , RemoveOcean = T){
if(Toroid){
tU <- ToroidUmatrix(Umatrix, BestMatches, Cls)
Umatrix <- tU$Umatrix
BestMatches <- tU$BestMatches
Cls <- tU$Cls
}
BestMatches = CheckBestMatches(BestMatches, Cls)
if(!is.null(BestMatches)){
BestMatchesFilter = rep(T,nrow(BestMatches))
}
if(!is.null(Imx)){
for(i in 1:nrow(Imx)){
for(j in 1:ncol(Imx)){
if(Imx[i,j] == 1){
Umatrix[i,j] = NA
if(!is.null(BestMatches))
BestMatchesFilter[(BestMatches[,2] == i) & (BestMatches[,3] == j)] = F
}
}
}
if(!is.null(BestMatches)) BestMatches = BestMatches[BestMatchesFilter,]
if((!is.null(Cls)) & (!is.null(BestMatches))) Cls = Cls[BestMatchesFilter]
}
if(RemoveOcean){
oceanLine = !apply(Umatrix, 1, function(x) any(x != -1))
startLine = min(which(!oceanLine),na.rm=T)
endLine = length(oceanLine) - min(which(rev(!oceanLine)),na.rm=T) + 1
oceanCol = !apply(Umatrix, 2, function(x) any(x != -1))
startCol = min(which(!oceanCol),na.rm=T)
endCol = length(oceanCol) - min(which(rev(!oceanCol)),na.rm=T) + 1
if(!is.null(BestMatches)){
BestMatches <- BestMatches - cbind(rep(0,nrow(BestMatches)),startLine-1,startCol-1)
}
Umatrix <- Umatrix[startLine:endLine,startCol:endCol]
}
Umatrix[which(is.na(Umatrix))] = 0
return(list(Umatrix = Umatrix, BestMatches = BestMatches, Cls=Cls))
} |
calc.poss.detect.dists.lines <- function(population, survey, perp.truncation, plot = FALSE){
transects <- [email protected]
individuals <- population@population
for(i in seq(along = individuals$object)){
x.coord <- individuals[i,"x"]
y.coord <- individuals[i,"y"]
transect.angle <- atan2(transects[["end.Y"]]-transects[["start.Y"]], transects[["end.X"]]-transects[["start.X"]])
animal.angle <- atan2(y.coord-transects[["start.Y"]], x.coord-transects[["start.X"]])
delta.angle <- abs(animal.angle-transect.angle)
delta.angle <- (ifelse(delta.angle > pi, 2*pi - delta.angle, delta.angle))
hyp <- sqrt((y.coord-transects[["start.Y"]])^2+(x.coord-transects[["start.X"]])^2)
all.perp.dists <- hyp*sin(delta.angle)
intersects.transects <- apply(cbind(transects[,c("start.X", "start.Y", "end.X", "end.Y", "length")], p.dist = all.perp.dists), 1, FUN = check.intersection.TP, point = data.frame(x = x.coord, y = y.coord), display.diagnostics = FALSE)
perp.dists <- ifelse(intersects.transects & all.perp.dists < perp.truncation, TRUE, FALSE)
detect.dists <- data.frame(object = rep(individuals[i,"object"], length(transects$ID)), transect.ID = transects$ID, distance = all.perp.dists, available = perp.dists)
if(i == 1){
poss.detect.dists <- detect.dists
}else{
poss.detect.dists <- rbind(poss.detect.dists, detect.dists)
}
}
poss.detect.dists <- poss.detect.dists[poss.detect.dists$available,]
poss.detect.dists <- merge(poss.detect.dists, individuals, by="object")
if(plot){
transect.IDs <- sort(unique(poss.detect.dists$transect.ID))
for(i in seq(along = transect.IDs)){
points(poss.detect.dists$x[poss.detect.dists$transect.ID == transect.IDs[i]], poss.detect.dists$y[poss.detect.dists$transect.ID == transect.IDs[i]], col = i, pch = 20)
points(poss.detect.dists$x[poss.detect.dists$transect.ID == transect.IDs[i]], poss.detect.dists$y[poss.detect.dists$transect.ID == transect.IDs[i]], col = i)
}
}
if(nrow(poss.detect.dists) > 0){
index <- order(poss.detect.dists$object)
poss.detect.dists <- poss.detect.dists[index,]
row.names(poss.detect.dists) <- 1:nrow(poss.detect.dists)
}
return(poss.detect.dists)
} |
formatted <-
function(x, digits=2){
output <- formatC(x, format="f", digits=digits)
return(output)
} |
associationsToDiamondPlotDf <- function(dat, covariates, criterion,
labels = NULL,
decreasing=NULL,
conf.level=.95,
esMetric = 'r') {
if (is.null(labels)) labels <- covariates;
assocMatrix <- ufs::associationMatrix(dat, x=covariates, y=criterion,
conf.level=conf.level);
resDf <- data.frame(lo = as.numeric(assocMatrix$output$raw$ci.lo),
es = as.numeric(assocMatrix$output$raw$es),
hi = as.numeric(assocMatrix$output$raw$ci.hi));
if (esMetric == 'r') {
resDf <- data.frame(matrix(sapply(1:length(covariates), function(i) {
if (assocMatrix$output$raw$esType[i] == 'd') {
return(ufs::convert.d.to.r(resDf[i, ]));
} else if ((assocMatrix$output$raw$esType[i] == 'etasq') ||
(assocMatrix$output$raw$esType[i] == 'omegasq')) {
return(sqrt(resDf[i, ]));
} else {
return(resDf[i, ]);
}
}), ncol=3, byrow=TRUE));
} else if (esMetric == 'd' | esMetric == 'g') {
resDf <- data.frame(matrix(sapply(1:length(covariates), function(i) {
if (assocMatrix$output$raw$esType[i] == 'r' | assocMatrix$output$raw$esType[i] == 'v') {
return(ufs::convert.r.to.d(resDf[i, ]));
} else if ((assocMatrix$output$raw$esType[i] == 'etasq') ||
(assocMatrix$output$raw$esType[i] == 'omegasq')) {
return(ufs::convert.r.to.d(sqrt(resDf[i, ])));
} else {
return(resDf[i, ]);
}
}), ncol=3, byrow=TRUE));
} else {
stop("No other effect size metrics implemented yet!");
}
names(resDf) <- c('lo', 'es', 'hi');
resDf$label <- labels;
resDf$rownr <- 1:nrow(resDf);
resDf$constant <- 1;
if (!is.null(decreasing)) {
sortedByMean <- order(unlist(resDf$es), decreasing=!decreasing);
resDf <- resDf[sortedByMean, ];
labels <- labels[sortedByMean];
} else {
sortedByMean <- 1:length(labels);
}
attr(resDf, 'sortedByMean') <- sortedByMean;
return(resDf);
} |
library(analogsea)
source("analog-keys.R")
install <- function(droplet){
droplet %>%
debian_add_swap() %>%
install_new_r() %>%
install_docker() %>%
prepare_plumber()
}
install_docker <- function(droplet){
droplet %>%
droplet_ssh(c("sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D",
"echo 'deb https://apt.dockerproject.org/repo ubuntu-focal main' > /etc/apt/sources.list.d/docker.list")) %>%
debian_apt_get_update() %>%
droplet_ssh("sudo apt-get install linux-image-extra-$(uname -r)") %>%
debian_apt_get_install("docker-engine") %>%
droplet_ssh(c("curl -L https://github.com/docker/compose/releases/download/1.7.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose",
"chmod +x /usr/local/bin/docker-compose"))
}
install_new_r <- function(droplet){
droplet %>%
droplet_ssh(c("echo 'deb https://cran.rstudio.com/bin/linux/ubuntu focal-cran40/' >> /etc/apt/sources.list",
"sudo apt-key adv --keyserver keys.gnupg.net --recv-key 'E298A3A825C0D65DFD57CBB651716619E084DAB9'")) %>%
debian_apt_get_update() %>%
debian_install_r()
}
prepare_plumber<- function(droplet){
droplet %>%
droplet_ssh("git clone https://github.com/rstudio/plumber.git") %>%
droplet_ssh("cd plumber/inst/hosted/ && docker-compose up -d --build")
} |
ste_dietrich2004 <- function(wave, U) {
e <- vector(mode="numeric", length=length(wave@left))
for (i in (U/2+1):(length(wave@left)-U/2)) {
values <- (i-U/2):(i+U/2)
values <- values[values > 0]
e[i] <- sum(abs(wave@left[values]))
}
return(e)
} |
apollo_estimateHB <- function(apollo_beta, apollo_fixed, apollo_probabilities, apollo_inputs, estimate_settings=NA){
time1 <- Sys.time()
database = apollo_inputs[["database"]]
apollo_control = apollo_inputs[["apollo_control"]]
draws = apollo_inputs[["draws"]]
apollo_randCoeff = apollo_inputs[["apollo_randCoeff"]]
apollo_lcPars = apollo_inputs[["apollo_lcPars"]]
apollo_HB = apollo_inputs[["apollo_HB"]]
workInLogs = apollo_control$workInLogs
estimationRoutine = tolower( estimate_settings[["estimationRoutine"]] )
maxIterations = estimate_settings[["maxIterations"]]
writeIter = estimate_settings[["writeIter"]]
hessianRoutine = estimate_settings[["hessianRoutine"]]
printLevel = estimate_settings[["printLevel"]]
silent = estimate_settings[["silent"]]
numDeriv_settings = estimate_settings[["numDeriv_settings"]]
constraints = estimate_settings[["constraints"]]
scaling = estimate_settings[["scaling"]]
bootstrapSE = estimate_settings[["bootstrapSE"]]
bootstrapSeed = estimate_settings[["bootstrapSeed"]]
if(length(apollo_inputs$apollo_scaling)>0 && !is.na(apollo_inputs$apollo_scaling)){
if(!is.null(apollo_HB$gVarNamesFixed)){
r <- ( names(apollo_beta) %in% names(apollo_inputs$apollo_scaling) ) & ( names(apollo_beta) %in% apollo_HB$gVarNamesFixed )
r <- names(apollo_beta)[r]
apollo_HB$FC[r] <- 1/apollo_inputs$apollo_scaling[r]*apollo_HB$FC[r]
rm(r)
}
if(!is.null(apollo_HB$gVarNamesNormal)){
r <- ( names(apollo_beta) %in% names(apollo_inputs$apollo_scaling) ) & ( names(apollo_beta) %in% apollo_HB$gVarNamesNormal )
r <- names(apollo_beta)[r]
dists_normal= names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==1])
dists_lnp = names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==2])
dists_lnn = names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==3])
dists_cnp = names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==4])
dists_cnn = names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==5])
dists_sb = names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==6])
s <- apollo_inputs$apollo_scaling
if(length(dists_normal)>0) apollo_HB$svN[dists_normal] <- 1/s[dists_normal]*apollo_HB$svN[dists_normal]
if(length(dists_lnp)>0) apollo_HB$svN[dists_lnp] <- -log(s[dists_lnp]) + apollo_HB$svN[dists_lnp]
if(length(dists_lnn)>0) apollo_HB$svN[dists_lnn] <- -log(s[dists_lnn]) + apollo_HB$svN[dists_lnn]
if(length(dists_cnp)>0) apollo_HB$svN[dists_cnp] <- 1/s[dists_cnp]*apollo_HB$svN[dists_cnp]
if(length(dists_cnn)>0) apollo_HB$svN[dists_cnn] <- 1/s[dists_cnn]*apollo_HB$svN[dists_cnn]
if(length(dists_sb)>0){
names(apollo_HB$gMINCOEF)=names(apollo_HB$svN)
names(apollo_HB$gMAXCOEF)=names(apollo_HB$svN)
apollo_HB$gMINCOEF[dists_sb] <- 1/s[dists_sb]*apollo_HB$gMINCOEF[dists_sb]
apollo_HB$gMAXCOEF[dists_sb] <- 1/s[dists_sb]*apollo_HB$gMAXCOEF[dists_sb]
}
rm(r, dists_normal, dists_lnp, dists_lnn, dists_cnp, dists_cnn, dists_sb)
}
}
apollo_probabilities <- apollo_insertComponentName(apollo_probabilities)
starttime <- Sys.time()
apollo_test_beta=apollo_beta
if(!apollo_control$noValidation){
if(!silent) cat("Testing probability function (apollo_probabilities)\n")
apollo_test_beta=apollo_beta
if(!is.null(apollo_HB$gVarNamesFixed)){
r <- ( names(apollo_beta) %in% apollo_HB$gVarNamesFixed )
r <- names(apollo_beta)[r]
apollo_test_beta[r] <- apollo_HB$FC[r]
}
if(!is.null(apollo_HB$gVarNamesNormal)){
r <- ( names(apollo_beta) %in% apollo_HB$gVarNamesNormal )
r <- names(apollo_beta)[r]
dists_normal=names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==1])
dists_lnp=names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==2])
dists_lnn=names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==3])
dists_cnp=names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==4])
dists_cnn=names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==5])
dists_sb=names(apollo_HB$gDIST[r][apollo_HB$gDIST[r]==6])
if(length(dists_normal)>0) apollo_test_beta[dists_normal] <- apollo_HB$svN[dists_normal]
if(length(dists_lnp)>0) apollo_test_beta[dists_lnp] <- exp(apollo_HB$svN[dists_lnp])
if(length(dists_lnn)>0) apollo_test_beta[dists_lnn] <- -exp(apollo_HB$svN[dists_lnn])
if(length(dists_cnp)>0) apollo_test_beta[dists_cnp] <- apollo_HB$svN[dists_cnp]*(apollo_HB$svN[dists_cnp]>0)
if(length(dists_cnn)>0) apollo_test_beta[dists_cnn] <- apollo_HB$svN[dists_cnn]*(apollo_HB$svN[dists_cnn]<0)
if(length(dists_sb)>0){
names(apollo_HB$gMINCOEF)=names(apollo_HB$svN)
names(apollo_HB$gMAXCOEF)=names(apollo_HB$svN)
apollo_test_beta[dists_sb] <- apollo_HB$gMINCOEF[dists_sb]+(apollo_HB$gMAXCOEF[dists_sb]-apollo_HB$gMINCOEF[dists_sb])/(1+exp(-apollo_HB$svN[dists_sb]))
}
}
apollo_probabilities(apollo_test_beta, apollo_inputs, functionality="validate")
testLL = apollo_probabilities(apollo_test_beta, apollo_inputs, functionality="estimate")
if(!workInLogs) testLL=log(testLL)
if(anyNA(testLL)) stop('Log-likelihood calculation fails at starting values!')
apollo_beta_base=apollo_test_beta+(!(names(apollo_beta)%in%(apollo_fixed)))*0.001*runif(length(apollo_beta))
base_LL=apollo_probabilities(apollo_beta_base, apollo_inputs, functionality="estimate")
if(workInLogs) base_LL=sum(base_LL) else base_LL=sum(log(base_LL))
freeparams=apollo_beta_base[!names(apollo_beta_base)%in%apollo_fixed]
for(p in names(freeparams)){
apollo_beta_test1=apollo_beta_base
apollo_beta_test2=apollo_beta_base
apollo_beta_test1[p]=apollo_beta_test1[p]-0.001
apollo_beta_test2[p]=apollo_beta_test2[p]+0.001
test1_LL=apollo_probabilities(apollo_beta_test1, apollo_inputs, functionality="estimate")
test2_LL=apollo_probabilities(apollo_beta_test2, apollo_inputs, functionality="estimate")
if(workInLogs){
test1_LL=sum(test1_LL)
test2_LL=sum(test2_LL)
} else{
test1_LL=sum(log( ifelse(!is.finite(test1_LL) | test1_LL<=0, .1, test1_LL) ))
test2_LL=sum(log( ifelse(!is.finite(test2_LL) | test2_LL<=0, .1, test2_LL) ))
}
if(is.na(test1_LL)) test1_LL <- base_LL + 1
if(is.na(test2_LL)) test2_LL <- base_LL + 2
if(base_LL==test1_LL & base_LL==test2_LL) stop("Parameter ",p," does not influence the log-likelihood of your model!")
}
}
tmp <- tryCatch( get("apollo_fixed", envir=globalenv()), error=function(e) 1 )
if( length(tmp)>0 && any(tmp %in% c(apollo_HB$gVarNamesFixed, apollo_HB$gVarNamesFixed)) ) stop("apollo_fixed seems to have changed since calling apollo_inputs.")
gFix <- apollo_HB$gVarNamesFixed
gNor <- apollo_HB$gVarNamesNormal
apollo_HB_likelihood=function(fc,b){
if(is.null(gFix)) fc1 <- NULL else fc1 <- stats::setNames(as.list(fc) , gFix)
if(is.null(gNor)) b1 <- NULL else b1 <- stats::setNames(as.data.frame(b), gNor)
if(length(apollo_fixed)==0) fp <- NULL else fp <- stats::setNames( as.list(apollo_beta[apollo_fixed]), apollo_fixed )
P <- apollo_probabilities(apollo_beta=c(fc1,b1,fp), apollo_inputs, functionality="estimate")
return(P)
}
time2 <- Sys.time()
currentWD <- getwd()
if(dir.exists(apollo_inputs$apollo_control$outputDirectory)) setwd(apollo_inputs$apollo_control$outputDirectory)
model <- RSGHB::doHB(apollo_HB_likelihood, database, apollo_HB)
setwd(currentWD)
time3 <- Sys.time()
model$apollo_HB <- apollo_HB
model$apollo_beta <- apollo_test_beta
model$LLStart <- sum(testLL)
if(workInLogs) model$LL0 <- sum((apollo_probabilities(apollo_beta, apollo_inputs, functionality="zero_LL"))) else model$LL0 <- sum(log(apollo_probabilities(apollo_beta, apollo_inputs, functionality="zero_LL")))
model$startTime <- starttime
model$apollo_control <- apollo_control
model$nObs <- nrow(database)
model$nIndivs <- length(unique(database[,apollo_control$indivID]))
endtime <- Sys.time()
model$timeTaken <- as.numeric(difftime(endtime,starttime,units='secs'))
model$apollo_fixed <- apollo_fixed
model$estimationRoutine <- "Hierarchical Bayes"
if(!is.null(model$F)){
tmp <- coda::geweke.diag(model$F[,2:(ncol(model$F))], frac1=0.1, frac2=0.5)[[1]]
names(tmp) <- model$params.fixed
model$F_convergence=tmp
}
if(!is.null(model$A)){
tmp <- coda::geweke.diag(model$A[,2:(ncol(model$A))], frac1=0.1, frac2=0.5)[[1]]
model$A_convergence=tmp
}
if(!is.null(model$D)){
tmp <- c()
for(i in 1:dim(model$D)[1]) for(j in 1:i){
if(i==1 & j==1) Dmatrix <- as.matrix(model$D[i,j,]) else Dmatrix <- cbind(Dmatrix, as.vector(model$D[i,j,]))
tmp <- c(tmp, paste(colnames(model$A)[i+1],colnames(model$A)[j+1], sep="_"))
}
colnames(Dmatrix) <- tmp
tmp <- coda::geweke.diag(Dmatrix, frac1=0.1, frac2=0.5)[[1]]
model$D_convergence=tmp
}
if(length(apollo_HB$gVarNamesFixed)>0 | length(model$apollo_fixed)>0){
if(length(apollo_HB$gVarNamesFixed)>0){
non_random=matrix(0,nrow=length(apollo_HB$gVarNamesFixed),2)
non_random[,1]=colMeans(model$F)[2:ncol(model$F)]
non_random[,2]=apply(model$F,FUN=stats::sd,2)[2:ncol(model$F)]
rownames(non_random)=apollo_HB$gVarNamesFixed}
if(length(model$apollo_fixed)>0){
if(length(apollo_HB$gVarNamesFixed)>0){
non_random=rbind(non_random,cbind(matrix(model$apollo_beta[model$apollo_fixed]),NA))
rownames(non_random)[(length(apollo_HB$gVarNamesFixed)+1):nrow(non_random)]=model$apollo_fixed
} else{
non_random=cbind(matrix(model$apollo_beta[model$apollo_fixed]),NA)
rownames(non_random)=model$apollo_fixed
}
}
colnames(non_random)=c("Mean","SD")
originalOrder <- names(model$apollo_beta)[names(model$apollo_beta) %in% rownames(non_random)]
model$chain_non_random=non_random[originalOrder,,drop=FALSE]
}
apollo_HB$gVarNamesFixed <- model$params.fixed
apollo_HB$gVarNamesNormal <- model$params.vary
if(any(!is.null(apollo_HB$gVarNamesNormal)) && length(apollo_HB$gVarNamesNormal)>0){
random_mean = matrix(0,nrow=length(apollo_HB$gVarNamesNormal),2)
random_mean[,1] = colMeans(model$A)[2:ncol(model$A)]
random_mean[,2] = apply(model$A,FUN=stats::sd,2)[2:ncol(model$A)]
rownames(random_mean)=apollo_HB$gVarNamesNormal
colnames(random_mean)=c("Mean","SD")
model$chain_random_mean=random_mean
random_cov_mean = apply(model$D,FUN=mean,c(1,2))
random_cov_sd = apply(model$D,FUN=stats::sd,c(1,2))
rownames(random_cov_mean) = apollo_HB$gVarNamesNormal
colnames(random_cov_mean) = apollo_HB$gVarNamesNormal
model$chain_random_cov_mean=random_cov_mean
rownames(random_cov_sd) = apollo_HB$gVarNamesNormal
colnames(random_cov_sd) = apollo_HB$gVarNamesNormal
model$chain_random_cov_sd=random_cov_sd
posterior=matrix(0,nrow=length(apollo_HB$gVarNamesNormal),2)
posterior[,1]=colMeans(model$C)[3:ncol(model$C)]
posterior[,2]=apply(model$C,FUN=stats::sd,2)[3:ncol(model$C)]
rownames(posterior)=apollo_HB$gVarNamesNormal
model$posterior_mean=posterior
colnames(model$posterior_mean)=c("Mean","SD")
draws=10000
covMat=random_cov_mean
meanA=random_mean[,1]
pars = length(meanA)
covMat=as.matrix(covMat)
Ndraws=mvtnorm::rmvnorm(draws,meanA,covMat,method="chol")
for(i in 1:pars){
if(apollo_HB$gDIST[i]==6){
Ndraws[,i]=apollo_HB$gMINCOEF+(apollo_HB$gMAXCOEF[i]-apollo_HB$gMINCOEF[i])*1/(1+exp(-Ndraws[,i]))
}
if(apollo_HB$gDIST[i]==5){
Ndraws[,i]=(Ndraws[,i]<0)*Ndraws[,i]
}
if(apollo_HB$gDIST[i]==4){
Ndraws[,i]=(Ndraws[,i]>0)*Ndraws[,i]
}
if(apollo_HB$gDIST[i]==3){
Ndraws[,i]=-exp(Ndraws[,i])
}
if(apollo_HB$gDIST[i]==2){
Ndraws[,i]=exp(Ndraws[,i])
}
}
}
if(length(scaling)>0 && !is.na(scaling)){
for(s in 1:length(scaling)){
ss=names(scaling)[s]
if(ss%in%colnames(model$C)) model$C[,ss]=scaling[s]*model$C[,ss]
if(ss%in%colnames(model$Csd)) model$Csd[,ss]=scaling[s]*model$Csd[,ss]
if(ss%in%colnames(model$F)) model$F[,ss]=scaling[s]*model$F[,ss]
if(any(!is.null(apollo_HB$gVarNamesNormal)) && length(apollo_HB$gVarNamesNormal)>0){if(ss%in%colnames(Ndraws)) Ndraws[,ss]=scaling[s]*Ndraws[,ss]}
if(ss%in%rownames(model$chain_non_random)) model$chain_non_random[ss,]=scaling[s]*model$chain_non_random[ss,]
if(ss%in%rownames(model$posterior_mean)) model$posterior_mean[ss,]=scaling[s]*model$posterior_mean[ss,]
}
model$scaling <- scaling
}
if(any(!is.null(apollo_HB$gVarNamesNormal)) && length(apollo_HB$gVarNamesNormal)>0){
model$random_coeff_summary=cbind(colMeans(Ndraws),apply(Ndraws,2,sd))
colnames(model$random_coeff_summary)=c("Mean","SD")
if(length(apollo_HB$gVarNamesNormal)>1){
model$random_coeff_covar=cov(Ndraws)
model$random_coeff_corr=cor(Ndraws)
}
}
panelData <- apollo_control$panelData
indivID <- database[,apollo_control$indivID]
nObs <- length(indivID)
if(!panelData) indivID <- 1:nObs
nIndiv <- length(unique(indivID))
obsPerIndiv <- as.vector(table(indivID))
if(is.null(model$chain_non_random)){
fc1 <- NULL
}else{
fc1 <- stats::setNames(as.list(model$chain_non_random[,1]),names(model$chain_non_random[,1]))
}
if(is.null(model$C)){
b1 <- NULL
}else{
M=model$C[,-c(1,2),drop=FALSE]
M1 <- matrix(0, nrow=nObs, ncol=ncol(M))
r1 <- 1
for(i in 1:nIndiv){
r2 <- r1 + obsPerIndiv[i] - 1
M1[r1:r2,] <- matrix(as.vector(M[i,]), nrow=r2-r1+1, ncol=ncol(M), byrow=TRUE)
r1 <- r2 + 1
}
b1 <- stats::setNames(as.data.frame(M1), colnames(M))
}
model$estimate=c(fc1,b1)
if(exists("apollo_HBcensor", envir=globalenv()) && !apollo_inputs$silent){
apollo_print(paste0('WARNING: RSGHB has censored the probabilities. ',
'Please note that in at least some iterations RSGHB has ',
'avoided numerical issues by left censoring the ',
'probabilities. This has the side effect of zero or ',
'negative probabilities not leading to failures!'))
rm("apollo_HBcensor", envir=globalenv())
}
time4 <- Sys.time()
model$timeTaken <- as.numeric(difftime(time4,time1,units='secs'))
model$timePre <- as.numeric(difftime(time2,time1,units='secs'))
model$timeEst <- as.numeric(difftime(time3,time2,units='secs'))
model$timePost <- as.numeric(difftime(time4,time3,units='secs'))
return(model)
} |
library(testthat)
if (Sys.getenv("TENSORFLOW_EAGER") == "TRUE")
tensorflow::tfe_enable_eager_execution()
library(keras)
if (identical(Sys.getenv("NOT_CRAN"), "true")) {
test_check("keras")
} |
makeEmissionFUN <-
function (errorRate = 0.01)
{
E <- log(errorRate)
E2 <- log(1 - errorRate)
E3 <- log(0.5)
function(h, x, n) {
if (h != 3)
return(ifelse(h == x, E2, E))
else return(n * E3)
}
} |
library(pROC)
test_that("roc rejects rejects invalid data", {
controls <- c(-Inf, 1,2,3,4,5)
cases <- c(2,3,4,5,6)
expect_warning(r <- roc(controls = controls, cases = cases), "Infinite value")
expect_equal(r, NaN)
controls <- c(1,2,3,4,5, Inf)
cases <- c(2,3,4,5,6)
expect_warning(r <- roc(controls = controls, cases = cases), "Infinite value")
expect_equal(r, NaN)
})
test_that("roc rejects rejects also valid data", {
controls <- c(1,2,3,4,5)
cases <- c(-Inf, 2,3,4,5,6)
expect_warning(r <- roc(controls = controls, cases = cases), "Infinite value")
expect_equal(r, NaN)
controls <- c(1,2,3,4,Inf)
cases <- c(2,3,4,5,6)
expect_warning(r <- roc(controls = controls, cases = cases), "Infinite value")
expect_equal(r, NaN)
}) |
em_mendelian <- function(typed.genos, M, ncores = 1) {
indices.typed.genos <- find_geno_index(typed.genos, M)
update.theta <- function(theta, mval) {
mu0 <- theta[1]
sd0 <- theta[2]
mu1 <- theta[3]
sd1 <- theta[4]
y <- c(dnorm(mval, mu0, sd0), dnorm(mval, mu1, sd1))
p01 <- matrix(y, length(mval), 2)
f <- function(j) {
datg <- typed.genos[[j]]
p01.fam <- p01[indices.typed.genos[[j]], ]
if (ncol(datg) == 2) p01.fam <- matrix(p01.fam, 1, )
p <- datg$p
for (k in 2:ncol(datg)) {
indices <- datg[, k] + 1
p <- p * p01.fam[k - 1, indices]
}
p <- p / sum(p)
g <- function(k) {
carriers <- (datg[, k] == 1)
sum(p[carriers])
}
q.famj <- sapply(2:ncol(datg), g)
q.famj
}
q.fams <- lapply(1:length(typed.genos), f)
q <- numeric(length(mval))
for (j in 1:length(typed.genos)) {
q[indices.typed.genos[[j]]] <- q.fams[[j]]
}
w0 <- (1 - q) / sum(1 - q)
w1 <- q / sum(q)
mu0 <- sum(w0 * mval)
sd0 <- sqrt(sum(w0 * (mval - mu0)^2))
mu1 <- sum(w1 * mval)
sd1 <- sqrt(sum(w1 * (mval - mu1)^2))
theta <- c(mu0, sd0, mu1, sd1)
theta
}
calc.ll.em <- function(theta, mval) {
mu0 <- theta[1]
sd0 <- theta[2]
mu1 <- theta[3]
sd1 <- theta[4]
y <- c(dnorm(mval, mu0, sd0), dnorm(mval, mu1, sd1))
p01 <- matrix(y, length(mval), 2)
f <- function(j) {
datg <- typed.genos[[j]]
p01.fam <- p01[indices.typed.genos[[j]], ]
if (ncol(datg) == 2) p01.fam <- matrix(p01.fam, 1, )
p <- datg$p
for (k in 2:ncol(datg)) {
indices <- datg[, k] + 1
p <- p * p01.fam[k - 1, indices]
}
ll.famj <- log(sum(p))
ll.famj
}
p.fams <- sapply(1:length(typed.genos), f)
ll <- sum(p.fams)
ll
}
em.maxlik <- function(i, tol = 1e-3, max.count = 200, theta.start = NULL) {
mval <- as.numeric(M[i, ])
n <- length(mval)
mu0 <- mean(mval)
sd0 <- sd(mval) * sqrt((n - 1) / n)
mu1 <- mu0
sd1 <- sd0
theta.null <- c(mu0, sd0, mu1, sd1)
if (is.null(theta.start)) {
theta.start <- theta.null
}
theta <- theta.start
continue <- TRUE
count <- 0
while (continue) {
count <- count + 1
theta.new <- update.theta(theta, mval)
continue <- all(!is.na(theta.new)) & any(abs(theta.new - theta) > tol) &
(count < max.count)
theta <- theta.new
}
ll.start <- calc.ll.em(theta.null, mval)
ll.end <- calc.ll.em(theta, mval)
c(ll.start, ll.end, theta.null[1:2], theta, count)
}
em.maxlik.best <- function(i) {
theta_start_values <- list(
NULL, c(-2, 1, 2, 1), c(2, 1, -2, 1)
)
out <- vector("list", length = 3)
for (j in seq_along(out)) {
out[[j]] <- em.maxlik(i, theta.start = theta_start_values[[j]])
}
out <- matrix(unlist(out, use.names = FALSE), nrow = 3, byrow = TRUE)
out_noinf <- rbind(out[out[, 2] != Inf, ])
max_out <- out_noinf[which.max(out_noinf[, 2]), ]
if (length(max_out) == 0) {
max_out <- out[1, ]
max_out[-c(1, 3, 4)] <- NA
}
max_out
}
nprobe <- nrow(M)
if (ncores == 1) {
out <- sapply(1:nprobe, em.maxlik.best)
} else {
cl <- parallel::makeCluster(ncores)
on.exit(parallel::stopCluster(cl), add = TRUE)
out <- parallel::parSapply(cl, 1:nprobe, em.maxlik.best)
}
out <- data.frame(probe = rownames(M)[1:nprobe], as.data.frame(t(out)))
names(out) <- c("probe", "ll.null", "ll.mendel", "mu.null", "sd.null",
"mu0", "sd0", "mu1", "sd1", "count")
out
} |
`analyse.models` <-
function (file, size.freq = TRUE, moco = c(20, 10), int.freq = TRUE,
kmax = 10, int.level = 2, bin.names = NULL)
{
ones <- function(model) {
(model[begin] == 1) * abs(model[begin + 1])
}
twos <- function(model) {
ifelse(model[begin] == 2, paste(model[begin + 1], model[begin +
2]), "0 0")
}
threes <- function(model) {
ifelse(model[begin] == 3, paste(model[begin + 1], model[begin +
2], model[begin + 3]), "0 0 0")
}
sub.names <- function(obj, new.names) {
nbin <- length(new.names)
temp <- paste("", names(obj), "")
for (i in -nbin:nbin){
temp <- gsub(pattern = paste("", i, ""), replacement = paste("",
paste(ifelse(i < 0, "-", ""), new.names[abs(i)], sep = ""), ""), x = temp)
}
end <- unlist(lapply(strsplit(temp, split = ""), length)) - 1
temp <- substring(temp, first = 2, last = end)
temp
}
erg <- read.table(file)
n <- dim(erg)[1]
fac <- ifelse(int.freq, 1, n)
sizes <- ifelse(size.freq, table(erg[, 1]), table(erg[,1])/n)
models <- erg[, 2:((int.level + 1) * kmax + 1)]
begin <- seq(1, by = int.level + 1, length.out = kmax)
only.ones <- apply(models, 1, ones)
only.ones <- sort(table(as.vector(only.ones[only.ones > 0])), decreasing = TRUE)/fac
if (!is.null(bin.names))
names(only.ones) <- sub.names(only.ones, new.names = bin.names)
only.twos <- apply(models, 1, twos)
only.twos <- sort(table(as.vector(only.twos[only.twos !=
"0 0"])), decreasing = TRUE)/fac
if (!is.null(bin.names)) {
names(only.twos) <- sub.names(only.twos, new.names = bin.names)
}
if (length(moco) > 2) {
only.threes <- apply(models, 1, threes)
only.threes <- sort(table(as.vector(only.threes[only.threes !=
"0 0 0"])), decreasing = TRUE)[1:moco[3]]/fac
if (!is.null(bin.names)) {
names(only.threes) <- sub.names(only.threes, new.names = bin.names)
}
}
else {
only.threes <- NULL
}
list(size = sizes, ones = only.ones[1:moco[1]], twos = only.twos[1:moco[2]],
threes = only.threes)
} |
setMethod("sqlCreateTable", signature("GreenplumConnection"),
function(con, table, fields, row.names = NA, temporary = FALSE,
distributed_by = NULL, ...) {
table <- dbQuoteIdentifier(con, table)
if (is.data.frame(fields)) {
fields <- DBI::sqlRownamesToColumn(fields, row.names)
fields <- vapply(fields, function(x) DBI::dbDataType(con, x), character(1))
}
field_names <- dbQuoteIdentifier(con, names(fields))
field_types <- unname(fields)
fields <- paste0(field_names, " ", field_types)
distribution <- if(is.null(distributed_by)){
"DISTRIBUTED RANDOMLY"
} else{
paste0("(",
paste(distributed_by, collapse = ", "),
")")
}
DBI::SQL(paste0(
"CREATE ", if (temporary) "TEMPORARY ", "TABLE ", table, " (\n",
" ", paste(fields, collapse = ",\n "), "\n)\n ",
distribution
))
}
) |
plot.pkgDepGraph <- function(
x, pkgsToHighlight,
main = paste(attr(x, "pkgs"), collapse = ", "),
legendPosition = c(-1.2, -1),
shape = "circle",
vertex.size = 8,
cex = 1,
...)
{
class(x) <- "igraph"
plotColours <- c("grey80", "orange")
if(missing("pkgsToHighlight")) {
pkgsToHighlight <- attr(x, "pkgs")
}
topLevel <- as.numeric(igraph::V(x)$name %in% pkgsToHighlight)
vColor <- plotColours[1 + topLevel]
vFont <- 1 + topLevel
vShape <- c("none", shape)[1 + topLevel]
edgeColor <- c(Imports = "red", Depends = "orange", Suggests = "grey80", Enhances = "blue", LinkingTo = "black")
eColor <- edgeColor[igraph::get.edge.attribute(x, "type")]
typesInGraph <- unique(igraph::get.edge.attribute(x, "type"))
edgeColor <- edgeColor[typesInGraph]
par(mai = rep(0.25, 4))
igraph::plot.igraph(x, vertex.size = vertex.size,
edge.arrow.size = 0.5,
edge.color = eColor,
vertex.label.cex = cex,
vertex.label.color = "black",
vertex.color = vColor,
vertex.shape = vShape,
vertex.label.font = vFont,
xlim = c(-1.5, 1)
)
pch1 <- rep(19, length(plotColours))
pch2 <- rep(-8594, length(edgeColor))
yjust <- function(x) 0.5 * (x + 1)
xjust <- function(x) 1
if(!is.null(legendPosition)) {
legend(x = legendPosition[1],
y = legendPosition[2],
xjust = xjust(legendPosition[1]),
yjust = yjust(legendPosition[2]),
legend = names(edgeColor),
col = edgeColor,
pch = pch2,
y.intersp = 0.75,
cex = cex)
}
title(main, cex = cex)
} |
observeEvent(input$finalok, {
num_data <- final_split$train[, sapply(final_split$train, is.factor)]
if (is.null(dim(num_data))) {
k <- final_split$train %>% map(is.factor) %>% unlist()
j <- names(which(k == TRUE))
numdata <- tibble::as_data_frame(num_data)
colnames(numdata) <- j
updateSelectInput(session, 'var1_cross',
choices = names(numdata), selected = names(numdata))
updateSelectInput(session, 'var2_cross',
choices = names(numdata), selected = names(numdata))
} else if (ncol(num_data) < 1) {
updateSelectInput(session, 'var1_cross',
choices = '', selected = '')
updateSelectInput(session, 'var2_cross',
choices = '', selected = '')
} else {
updateSelectInput(session, 'var1_cross', choices = names(num_data))
updateSelectInput(session, 'var2_cross', choices = names(num_data))
}
})
d_cross <- eventReactive(input$submit_cross, {
data <- final_split$train[, c(input$var1_cross, input$var2_cross)]
})
conames <- reactive({
colnames(d_cross())
})
cross_out <- eventReactive(input$submit_cross, {
k <- ds_cross_table(final_split$train, !! sym(as.character(input$var1_cross)),
!! sym(as.character(input$var2_cross)))
k
})
output$cross <- renderPrint({
cross_out()
})
c1_title <- eventReactive(input$submit_cross, {
h3('Stacked Bar Plot', style = 'align:center;')
})
output$cross1_title <- renderUI({
c1_title()
})
c2_title <- eventReactive(input$submit_cross, {
h3('Grouped Bar Plot', style = 'align:center;')
})
output$cross2_title <- renderUI({
c2_title()
})
c3_title <- eventReactive(input$submit_cross, {
h3('Proportional Bar Plot', style = 'align:center;')
})
output$cross3_title <- renderUI({
c3_title()
})
output$cross_bar_stacked <- renderPlot({
plot(cross_out(), stacked = TRUE)
})
output$cross_bar_grouped <- renderPlot({
plot(cross_out())
})
output$cross_bar_proportional <- renderPlot({
plot(cross_out(), proportional = TRUE)
}) |
"%primes%" <- function(size, start_at) {
assert_collection <- checkmate::makeAssertCollection()
checkmate::assert_count(x = size, add = assert_collection)
checkmate::assert_count(x = start_at, positive = TRUE, add = assert_collection)
checkmate::reportAssertions(assert_collection)
if (start_at >= size)
assert_collection$push("'start_at' must be smaller than 'size'.")
checkmate::reportAssertions(assert_collection)
n_groups <- ceiling(size / start_at)
group_data <- data.frame(
"groups" = seq_len(n_groups),
stringsAsFactors = FALSE
)
group_data <- group_data %>%
dplyr::mutate(
n_elements = create_n_primes(length(.data$groups), start_at),
cumsum = cumsum(as.numeric(.data$n_elements))
)
last_group_row <- group_data[group_data[["cumsum"]] >= size, ][1, ]
cumsum_last_group <- last_group_row[1, 3]
n_elements_last_group <- last_group_row[1, 2]
excess_elements <- cumsum_last_group - size
if (excess_elements == 0) {
remainder <- 0
} else {
remainder <- n_elements_last_group - excess_elements
}
remainder
} |
mc_index <- function() {
path <- "https://multicast.aspra.uni-bamberg.de/data/mcr/mc_index.tsv"
message("Retrieving Multi-CAST version index...")
index <- tryCatch(suppressWarnings(read.csv(path,
sep = "\t",
colClasses = c("factor",
"character",
"character",
rep("numeric", 2)),
header = TRUE)),
error = function(e) {
stop(paste0("Failed to download index. Cannot access file.\n",
" The University of Bamberg servers seem to be experiencing problems.\n",
" Please try again later."),
call. = FALSE)
}
)
message("Downloaded <1 KB.")
return(index)
} |
caImportance<-function(y,x)
{
options(contrasts=c("contr.sum", "contr.poly"))
outdec<-options(OutDec="."); on.exit(options(outdec))
options(OutDec=",")
y<-m2v(y)
m<-length(x)
n<-nrow(x)
S<-nrow(y)/n
xnms<-names(x)
Lj<-vector("numeric",m)
for (j in 1:m) {Lj[j]<-nlevels(factor(x[[xnms[j]]]))}
p<-sum(Lj)-m+1
xtmp<-paste("factor(x$",xnms,sep="",paste(")"))
xfrm<-paste(xtmp,collapse="+")
usl<-partutils(xfrm,y,x,n,p,S)
imps<-matrix(0,S,m)
for(s in 1:S)
{
u<-usl[s,]
ul<-utilities(u,Lj)
imp<-importance(ul,Lj)*100
imps[s,]<-imp
}
impS<-round(apply(imps,2,"mean"),2)
return(impS)
} |
print.rvfactor <- function(x, all.levels=FALSE, ...) {
s <- summary(x, all.levels=all.levels)
ds <- dimnames(s)
if (!is.null(.names <- names(x))) {
s <- cbind(name=.names, s)
} else if (!is.null(.dn <- dimnames(x))) {
sud <- rvpar("summary.dimnames")
if (!is.null(sud) && !is.na(sud) && is.logical(sud)) {
da <- lapply(.dn, function (na) if (is.null(na)) rep("", nrow(s)) else na)
rw <- da[[1]][row(x)]
cl <- da[[2]][col(x)]
s <- cbind(row=rw, col=cl, " "=":", s)
}
}
print(s)
} |
"battery_charging" |
trace_length_case <- function(eventlog) {
eventlog %>%
group_by_case %>%
summarize(absolute = n_distinct(!!activity_instance_id_(eventlog)))
} |
test_that("can convert unnamed vector", {
expect_identical(
enframe(3:1),
tibble(name = 1:3, value = 3:1)
)
})
test_that("can convert unnamed list", {
expect_identical(
enframe(as.list(3:1)),
tibble(name = 1:3, value = as.list(3:1))
)
})
test_that("can convert named vector", {
expect_identical(
enframe(c(a = 2, b = 1)),
tibble(name = letters[1:2], value = as.numeric(2:1))
)
})
test_that("can convert zero-length vector", {
expect_identical(
enframe(logical()),
tibble(name = integer(), value = logical())
)
})
test_that("can convert NULL (
expect_identical(
enframe(NULL),
tibble(name = integer(), value = logical())
)
})
test_that("can use custom names", {
expect_identical(
enframe(letters, name = "index", value = "letter"),
tibble(
index = seq_along(letters),
letter = letters
)
)
})
test_that("can enframe without names", {
expect_identical(
enframe(letters, name = NULL, value = "letter"),
tibble(letter = letters)
)
})
test_that("can't use value = NULL", {
expect_legacy_error(
enframe(letters, value = NULL),
error_enframe_value_null(),
fixed = TRUE
)
})
test_that("can't pass objects with dimensions", {
skip_enh_enframe_vector()
expect_legacy_error(
enframe(iris),
error_enframe_has_dim(iris),
fixed = TRUE
)
})
test_that("can deframe two-column data frame", {
expect_identical(
deframe(tibble(name = letters[1:3], value = 3:1)),
c(a = 3L, b = 2L, c = 1L)
)
})
test_that("can deframe one-column data frame", {
expect_identical(
deframe(tibble(value = 3:1)),
3:1
)
})
test_that("can deframe tibble with list column", {
expect_identical(
deframe(tibble(name = letters[1:3], value = as.list(3:1))),
setNames(as.list(3:1), nm = letters[1:3])
)
})
test_that("can deframe three-column data frame with warning", {
expect_warning(
expect_identical(
deframe(tibble(name = letters[1:3], value = 3:1, oops = 1:3)),
c(a = 3L, b = 2L, c = 1L)
),
"one- or two-column",
fixed = TRUE
)
}) |
leafsfirst.tail<-function(dendat, rho=0, refe=NULL, dist.type="euclid")
{
n<-dim(dendat)[1]
d<-dim(dendat)[2]
pcfhigh<-dendat+rho
pcfdown<-dendat-rho
if (is.null(refe)){
refe<-matrix(0,1,d)
for (i in 1:d) refe[1,i]<-mean(dendat[,i])
refe<-refe[1:d]
}
distat<-sqrt(pituus(dendat-t(matrix(refe,d,n))))
lkm<-n
infopointer<-seq(1,lkm)
if (length(rho)==1) rho<-rep(rho,lkm)
ord<-order(distat)
infopointer<-infopointer[ord]
parent<-matrix(0,lkm,1)
child<-matrix(0,lkm,1)
sibling<-matrix(0,lkm,1)
volume<-matrix(0,lkm,1)
radius<-matrix(0,lkm,1)
highestNext<-matrix(0,lkm,1)
boundrec<-matrix(0,lkm,2*d)
node<-lkm
parent[node]<-0
child[node]<-0
sibling[node]<-0
radius[node]<-distat[ord[node]]
volume[node]<-1
beg<-node
highestNext[node]<-0
note<-infopointer[node]
for (i in 1:d){
boundrec[node,2*i-1]<-pcfdown[note,i]
boundrec[node,2*i]<-pcfhigh[note,i]
}
j<-2
while (j<=lkm){
node<-lkm-j+1
highestNext[node]<-beg
beg<-node
rec1<-matrix(0,2*d,1)
note<-infopointer[node]
for (i in 1:d){
rec1[2*i-1]<-pcfdown[note,i]
rec1[2*i]<-pcfhigh[note,i]
}
boundrec[node,]<-rec1
radius[node]<-distat[ord[node]]
volume[node]<-1
curroot<-highestNext[beg]
prevroot<-beg
ekatouch<-0
while (curroot>0){
istouch<-touchstep.tail(node,curroot,boundrec,child,sibling,
infopointer,pcfdown,pcfhigh,rho,dendat,
dist.type=dist.type)
if (istouch==1){
parent[curroot]<-node
if (ekatouch==0) ekatouch<-1 else ekatouch<-0
if (ekatouch==1){
child[node]<-curroot
}
else{
sibling[lastsib]<-curroot
}
volume[node]<-volume[node]+volume[curroot]
radius[node]<-min(distat[ord[node]],distat[ord[curroot]])
rec1<-boundrec[node,]
rec2<-boundrec[curroot,]
boundrec[node,]<-boundbox(rec1,rec2)
highestNext[prevroot]<-highestNext[curroot]
}
if (istouch==0) prevroot<-curroot else lastsib<-curroot
curroot<-highestNext[curroot]
}
j<-j+1
}
root<-1
maxdis<-distat[ord[length(ord)]]
center<-t(dendat[infopointer,])
lf<-list(
parent=parent,volume=volume,center=center,level=radius,
root=root,
infopointer=infopointer,
refe=refe,maxdis=maxdis,
dendat=dendat)
return(lf)
} |
filter.dtplyr_step <- function(.data, ..., .preserve = FALSE) {
check_filter(...)
dots <- capture_dots(.data, ..., .j = FALSE)
if (filter_by_lgl_col(dots)) {
i <- call2("(", dots[[1]])
} else {
i <- Reduce(function(x, y) call2("&", x, y), dots)
}
step_subset_i(.data, i)
}
filter_by_lgl_col <- function(dots) {
if (length(dots) > 1) {
return(FALSE)
}
dot <- dots[[1]]
if (is_symbol(dot)) {
return(TRUE)
}
is_call(dot, name = "!", n = 1) && is_symbol(dot[[2]])
}
filter.data.table <- function(.data, ...) {
.data <- lazy_dt(.data)
filter(.data, ...)
}
check_filter <- function(...) {
dots <- enquos(...)
named <- have_name(dots)
for (i in which(named)) {
quo <- dots[[i]]
expr <- quo_get_expr(quo)
if (!is.logical(expr)) {
abort(c(
glue::glue("Problem with `filter()` input `..{i}`."),
x = glue::glue("Input `..{i}` is named."),
i = glue::glue("This usually means that you've used `=` instead of `==`."),
i = glue::glue("Did you mean `{name} == {as_label(expr)}`?", name = names(dots)[i])
), call = caller_env())
}
}
} |
library(aster2)
theta <- seq(-3, 3, 0.1)
cumfun <- function(theta) rep(0, length(theta))
moofun <- cumfun
voofun <- cumfun
thoofun <- cumfun
zeroth <- mapply(function(theta) cumulant(theta, fam.bernoulli(),
delta = -1)$zeroth, theta)
all.equal(zeroth, cumfun(theta))
first <- mapply(function(theta) cumulant(theta, fam.bernoulli(),
delta = -1, deriv = 1)$first, theta)
all.equal(first, moofun(theta))
second <- mapply(function(theta) cumulant(theta, fam.bernoulli(),
delta = - 1, deriv = 2)$second, theta)
all.equal(second, voofun(theta))
third <- mapply(function(theta) cumulant(theta, fam.bernoulli(),
delta = - 1, deriv = 3)$third, theta)
all.equal(third, thoofun(theta))
foo <- link(0, fam.bernoulli(), delta = -1, deriv = 1)
is.finite(foo$zeroth)
all.equal(0, foo$first)
cumfun <- function(theta) theta
moofun <- function(theta) rep(1, length(theta))
voofun <- function(theta) rep(0, length(theta))
thoofun <- voofun
zeroth <- mapply(function(theta) cumulant(theta, fam.bernoulli(),
delta = 1)$zeroth, theta)
all.equal(zeroth, cumfun(theta))
first <- mapply(function(theta) cumulant(theta, fam.bernoulli(),
delta = 1, deriv = 1)$first, theta)
all.equal(first, moofun(theta))
second <- mapply(function(theta) cumulant(theta, fam.bernoulli(),
delta = 1, deriv = 2)$second, theta)
all.equal(second, voofun(theta))
third <- mapply(function(theta) cumulant(theta, fam.bernoulli(),
delta = 1, deriv = 3)$third, theta)
all.equal(third, thoofun(theta))
foo <- link(1, fam.bernoulli(), delta = 1, deriv = 1)
is.finite(foo$zeroth)
all.equal(0, foo$first)
theta <- seq(-3, 3, 0.1)
cumfun <- function(theta) rep(0, length(theta))
moofun <- cumfun
voofun <- cumfun
thoofun <- cumfun
zeroth <- mapply(function(theta) cumulant(theta, fam.poisson(),
delta = -1)$zeroth, theta)
all.equal(zeroth, cumfun(theta))
first <- mapply(function(theta) cumulant(theta, fam.poisson(),
delta = -1, deriv = 1)$first, theta)
all.equal(first, moofun(theta))
second <- mapply(function(theta) cumulant(theta, fam.poisson(),
delta = - 1, deriv = 2)$second, theta)
all.equal(second, voofun(theta))
third <- mapply(function(theta) cumulant(theta, fam.poisson(),
delta = - 1, deriv = 3)$third, theta)
all.equal(third, thoofun(theta))
foo <- link(0, fam.poisson(), delta = -1, deriv = 1)
is.finite(foo$zeroth)
all.equal(0, foo$first)
cumfun <- function(theta) theta
moofun <- function(theta) rep(1, length(theta))
voofun <- function(theta) rep(0, length(theta))
thoofun <- voofun
zeroth <- mapply(function(theta) cumulant(theta, fam.zero.truncated.poisson(),
delta = -1)$zeroth, theta)
all.equal(zeroth, cumfun(theta))
first <- mapply(function(theta) cumulant(theta, fam.zero.truncated.poisson(),
delta = -1, deriv = 1)$first, theta)
all.equal(first, moofun(theta))
second <- mapply(function(theta) cumulant(theta, fam.zero.truncated.poisson(),
delta = -1, deriv = 2)$second, theta)
all.equal(second, voofun(theta))
third <- mapply(function(theta) cumulant(theta, fam.zero.truncated.poisson(),
delta = -1, deriv = 3)$third, theta)
all.equal(third, thoofun(theta))
foo <- link(1, fam.zero.truncated.poisson(), delta = -1, deriv = 1)
is.finite(foo$zeroth)
all.equal(0, foo$first)
set.seed(42)
d <- 4
theta <- matrix(rnorm(d * 25), ncol = d)
cumfun <- function(theta, delta) {
stopifnot(is.numeric(theta))
stopifnot(is.finite(theta))
stopifnot(length(theta) == d)
stopifnot(is.numeric(delta))
stopifnot(is.finite(delta))
stopifnot(length(delta) == d)
stopifnot(delta <= 0)
stopifnot(any(delta == 0))
inies <- delta == 0
d.too <- sum(inies)
if (d.too == 1) return(theta[inies])
theta.too <- theta[inies]
return(cumulant(theta.too, fam.multinomial(d.too))$zeroth)
}
moofun <- function(theta, delta) {
stopifnot(is.numeric(theta))
stopifnot(is.finite(theta))
stopifnot(length(theta) == d)
stopifnot(is.numeric(delta))
stopifnot(is.finite(delta))
stopifnot(length(delta) == d)
stopifnot(delta <= 0)
stopifnot(any(delta == 0))
inies <- delta == 0
d.too <- sum(inies)
if (d.too == 1) as.numeric(inies)
theta.too <- theta[inies]
foo <- cumulant(theta.too, fam.multinomial(d.too), deriv = 1)$first
bar <- rep(0, d)
bar[inies] <- foo
return(bar)
}
voofun <- function(theta, delta) {
stopifnot(is.numeric(theta))
stopifnot(is.finite(theta))
stopifnot(length(theta) == d)
stopifnot(is.numeric(delta))
stopifnot(is.finite(delta))
stopifnot(length(delta) == d)
stopifnot(delta <= 0)
stopifnot(any(delta == 0))
inies <- delta == 0
d.too <- sum(inies)
if (d.too == 1) return(matrix(0, d, d))
theta.too <- theta[inies]
foo <- cumulant(theta.too, fam.multinomial(d.too), deriv = 2)$second
bar <- matrix(0, d, d)
baz <- matrix(0, d, d.too)
baz[inies, ] <- foo
bar[ , inies] <- baz
return(bar)
}
thoofun <- function(theta, delta) {
stopifnot(is.numeric(theta))
stopifnot(is.finite(theta))
stopifnot(length(theta) == d)
stopifnot(is.numeric(delta))
stopifnot(is.finite(delta))
stopifnot(length(delta) == d)
stopifnot(delta <= 0)
stopifnot(any(delta == 0))
inies <- delta == 0
d.too <- sum(inies)
if (d.too == 1) return(array(0, rep(d, 3)))
theta.too <- theta[inies]
foo <- cumulant(theta.too, fam.multinomial(d.too), deriv = 3)$third
bar <- array(0, rep(d, 3))
baz <- array(0, c(d, d, d.too))
qux <- array(0, c(d, d.too, d.too))
qux[inies, , ] <- foo
baz[ , inies, ] <- qux
bar[ , , inies] <- baz
return(bar)
}
delta <- c(0, 0, 0, -1)
zeroth <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta)$zeroth)
my.zeroth <- apply(theta, 1, cumfun, delta = delta)
all.equal(zeroth, my.zeroth)
first <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 1)$first)
my.first <- apply(theta, 1, moofun, delta = delta)
all.equal(first, my.first)
second <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 2)$second)
my.second <- apply(theta, 1, voofun, delta = delta)
all.equal(second, my.second)
third <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 3)$third)
my.third <- apply(theta, 1, thoofun, delta = delta)
all.equal(third, my.third)
link(first[ , 1], fam.multinomial(d), delta = delta, deriv = 1)
delta <- c(0, 0, -1, -2)
zeroth <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta)$zeroth)
my.zeroth <- apply(theta, 1, cumfun, delta = delta)
all.equal(zeroth, my.zeroth)
first <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 1)$first)
my.first <- apply(theta, 1, moofun, delta = delta)
all.equal(first, my.first)
second <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 2)$second)
my.second <- apply(theta, 1, voofun, delta = delta)
all.equal(second, my.second)
third <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 3)$third)
my.third <- apply(theta, 1, thoofun, delta = delta)
all.equal(third, my.third)
link(first[ , 1], fam.multinomial(d), delta = delta, deriv = 1)
delta <- c(0, -0.5, -1, -2)
zeroth <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta)$zeroth)
my.zeroth <- apply(theta, 1, cumfun, delta = delta)
all.equal(zeroth, my.zeroth)
first <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 1)$first)
my.first <- apply(theta, 1, moofun, delta = delta)
all.equal(first, my.first)
second <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 2)$second)
my.second <- apply(theta, 1, voofun, delta = delta)
all.equal(second, my.second)
third <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 3)$third)
my.third <- apply(theta, 1, thoofun, delta = delta)
all.equal(third, my.third)
linkfun <- function(xi, delta) {
stopifnot(is.numeric(xi))
stopifnot(is.finite(xi))
stopifnot(length(xi) == d)
stopifnot(is.numeric(delta))
stopifnot(is.finite(delta))
stopifnot(length(delta) == d)
stopifnot(delta <= 0)
stopifnot(any(delta == 0))
inies <- delta == 0
d.too <- sum(inies)
if (d.too == 1) return(rep(0, d))
xi.too <- xi[inies]
foo <- link(xi.too, fam.multinomial(d.too))$zeroth
bar <- rep(0, d)
bar[inies] <- foo
return(bar)
}
dlinkfun <- function(xi, delta) {
stopifnot(is.numeric(xi))
stopifnot(is.finite(xi))
stopifnot(length(xi) == d)
stopifnot(is.numeric(delta))
stopifnot(is.finite(delta))
stopifnot(length(delta) == d)
stopifnot(delta <= 0)
stopifnot(any(delta == 0))
inies <- delta == 0
d.too <- sum(inies)
if (d.too == 1) return(matrix(0, d, d))
xi.too <- xi[inies]
foo <- link(xi.too, fam.multinomial(d.too), deriv = 1)$first
bar <- matrix(0, d, d)
baz <- matrix(0, d, d.too)
baz[inies, ] <- foo
bar[ , inies] <- baz
return(bar)
bar[inies] <- foo
return(bar)
}
delta <- c(0, 0, 0, -1)
xi <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 1)$first)
xi <- t(xi)
zeroth <- apply(xi, 1, function(xi) link(xi, fam.multinomial(d),
delta = delta)$zeroth)
my.zeroth <- apply(xi, 1, linkfun, delta = delta)
all.equal(zeroth, my.zeroth)
first <- apply(xi, 1, function(xi) link(xi, fam.multinomial(d),
delta = delta, deriv = 1)$first)
my.first <- apply(xi, 1, dlinkfun, delta = delta)
all.equal(first, my.first)
delta <- c(0, 0, -1, -2)
xi <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 1)$first)
xi <- t(xi)
zeroth <- apply(xi, 1, function(xi) link(xi, fam.multinomial(d),
delta = delta)$zeroth)
my.zeroth <- apply(xi, 1, linkfun, delta = delta)
all.equal(zeroth, my.zeroth)
first <- apply(xi, 1, function(xi) link(xi, fam.multinomial(d),
delta = delta, deriv = 1)$first)
my.first <- apply(xi, 1, dlinkfun, delta = delta)
all.equal(first, my.first)
delta <- c(0, -0.5, -1, -2)
xi <- apply(theta, 1, function(theta) cumulant(theta, fam.multinomial(d),
delta = delta, deriv = 1)$first)
xi <- t(xi)
zeroth <- apply(xi, 1, function(xi) link(xi, fam.multinomial(d),
delta = delta)$zeroth)
my.zeroth <- apply(xi, 1, linkfun, delta = delta)
all.equal(zeroth, my.zeroth)
first <- apply(xi, 1, function(xi) link(xi, fam.multinomial(d),
delta = delta, deriv = 1)$first)
my.first <- apply(xi, 1, dlinkfun, delta = delta)
all.equal(first, my.first) |
cournot <- function(prices,quantities,
margins = matrix(NA_real_ , nrow(quantities),ncol(quantities)),
demand = rep("linear",length(prices)),
cost = rep("linear",nrow(quantities)),
mcfunPre=list(),
mcfunPost=mcfunPre,
vcfunPre=list(),
vcfunPost=vcfunPre,
capacitiesPre = rep(Inf,nrow(quantities)),
capacitiesPost = capacitiesPre,
productsPre=!is.na(quantities),
productsPost=productsPre,
ownerPre,ownerPost,
mktElast = rep(NA_real_, length(prices)),
mcDelta =rep(0,nrow(quantities)),
quantityStart=as.vector(quantities),
control.slopes,
control.equ,
labels,
...
){
shares <- as.vector(quantities/sum(quantities))
if(missing(labels)){
if(is.null(dimnames(quantities))){
rname <- paste0("O",1:nrow(quantities))
cname <- paste0("P",1:ncol(quantities))
}
else{rname <- rownames(quantities)
cname <- colnames(quantities)
}
labels <- list(rname,cname)
}
result <- new("Cournot",prices=prices, quantities=quantities,margins=margins,
shares=shares,mcDelta=mcDelta, subset= rep(TRUE,length(shares)), demand = demand, cost=cost,
mcfunPre=mcfunPre, mcfunPost=mcfunPost,vcfunPre=vcfunPre, vcfunPost=vcfunPost,
capacitiesPre=capacitiesPre,capacitiesPost=capacitiesPost,
ownerPre=ownerPre, mktElast = mktElast,productsPre=productsPre,productsPost=productsPost,
ownerPost=ownerPost, quantityStart=quantityStart,labels=labels)
if(!missing(control.slopes)){
[email protected] <- control.slopes
}
if(!missing(control.equ)){
[email protected] <- control.equ
}
result@ownerPre <- ownerToMatrix(result,TRUE)
result@ownerPost <- ownerToMatrix(result,FALSE)
result <- calcSlopes(result)
result@quantityPre <- calcQuantities(result, preMerger = TRUE,...)
result@quantityPost <- calcQuantities(result,preMerger = FALSE,...)
result@pricePre <- calcPrices(result, preMerger = TRUE)
result@pricePost <- calcPrices(result,preMerger = FALSE)
return(result)
}
stackelberg <- function(prices,quantities,margins,
demand = rep("linear",length(prices)),
cost = rep("linear",nrow(quantities)),
isLeaderPre = matrix(FALSE,ncol = ncol(quantities), nrow= nrow(quantities)),
isLeaderPost= isLeaderPre,
mcfunPre=list(),
mcfunPost=mcfunPre,
vcfunPre=list(),
vcfunPost=vcfunPre,
dmcfunPre=list(),
dmcfunPost=dmcfunPre,
capacitiesPre = rep(Inf,nrow(quantities)),
capacitiesPost = capacitiesPre,
productsPre=!is.na(quantities),
productsPost=productsPre,
ownerPre,ownerPost,
mcDelta =rep(0,nrow(quantities)),
quantityStart=as.vector(quantities),
control.slopes,
control.equ,
labels,
...
){
shares <- as.vector(quantities/sum(quantities))
if(missing(labels)){
if(is.null(dimnames(quantities))){
rname <- paste0("O",1:nrow(quantities))
cname <- paste0("P",1:ncol(quantities))
}
else{rname <- rownames(quantities)
cname <- colnames(quantities)
}
labels <- list(rname,cname)
}
result <- new("Stackelberg",prices=prices, quantities=quantities,margins=margins,
shares=shares,mcDelta=mcDelta, subset= rep(TRUE,length(shares)), demand = demand, cost = cost,
mcfunPre=mcfunPre, mcfunPost=mcfunPost,vcfunPre=vcfunPre, vcfunPost=vcfunPost,
dmcfunPre=dmcfunPre, dmcfunPost=dmcfunPost, isLeaderPre = isLeaderPre, isLeaderPost = isLeaderPost,
ownerPre=ownerPre,productsPre=productsPre,productsPost=productsPost,
capacitiesPre=capacitiesPre,capacitiesPost=capacitiesPost,
ownerPost=ownerPost, quantityStart=quantityStart,labels=labels)
if(!missing(control.slopes)){
[email protected] <- control.slopes
}
if(!missing(control.equ)){
[email protected] <- control.equ
}
result@ownerPre <- ownerToMatrix(result,TRUE)
result@ownerPost <- ownerToMatrix(result,FALSE)
result <- calcSlopes(result)
result@quantityPre <- calcQuantities(result, preMerger = TRUE,...)
result@quantityPost <- calcQuantities(result,preMerger = FALSE,...)
result@pricePre <- calcPrices(result, preMerger = TRUE)
result@pricePost <- calcPrices(result,preMerger = FALSE)
return(result)
} |
envelope.Dtable <-
function (Y, fun = Kest, nsim = 99, nrank = 1, ..., funargs = list(),
funYargs = funargs, simulate = NULL, verbose = TRUE, savefuns = FALSE,
Yname = NULL, envir.simul = NULL)
{
cl <- spatstat.utils::short.deparse(sys.call())
if (is.null(Yname))
Yname <- spatstat.utils::short.deparse(substitute(Y))
if (is.null(fun))
fun <- Kest
envir.user <- if (!is.null(envir.simul))
envir.simul
else parent.frame()
envir.here <- sys.frame(sys.nframe())
if (is.null(simulate)) {
stop("The simulation function must be provided in the simulate argument.")
} else {
simrecipe <- simulate
X <- Y
}
envelopeEngine(X = X, fun = fun, simul = simrecipe, nsim = nsim,
nrank = nrank, ..., funargs = funargs, funYargs = funYargs,
verbose = verbose, clipdata = FALSE, transform = NULL,
global = FALSE, ginterval = NULL, use.theory = NULL,
alternative = c("two.sided", "less", "greater"), scale = NULL,
clamp = FALSE,
savefuns = savefuns, savepatterns = FALSE, nsim2 = nsim,
VARIANCE = FALSE, nSD = 2, Yname = Yname, maxnerr = nsim,
cl = cl, envir.user = envir.user, do.pwrong = FALSE,
foreignclass = "Dtable")
} |
RelCoef <-
function(IndividualGenom=matrix(0,nrow=0,ncol=0),ParentalLineGenom=matrix(0,nrow=0,ncol=0) ,Freq=matrix(0,nrow=0,ncol=0),Crossing=matrix(0,nrow=0,ncol=0),ParentPop=rep(0,0),Combination=list(),Phased=FALSE,Details=FALSE,NbInit=5,Prec=10^(-4),NbCores=NULL){
if ((nrow(IndividualGenom)==0) & (nrow(ParentalLineGenom)==0)){
stop("No genotype matrix provided")
}
if ((nrow(IndividualGenom)!=0) & (nrow(ParentalLineGenom)!=0)){
stop("Either a Parental genotype matrix OR a hybrid genotype matrix should be provided")
}
if (nrow(Freq)==0){
stop("Freq matrix should be provided")
}
if (nrow(IndividualGenom)!=0){
Genom <- IndividualGenom
if ((nrow(ParentalLineGenom)!=0) | (nrow(Crossing)!=0) | (length(ParentPop!=0))){
stop("If IndividualGenom is provided, ParentalLineGenom, Crossing and ParentPop cannot be provided")
}
Crossing <- matrix(seq(1:ncol(Genom)),ncol=2,byrow=T)
ParentPop <- rep(1,ncol(Genom))
} else {
Genom <- ParentalLineGenom
if (nrow(Crossing)==0){
stop("Crossing matrix should be provided")
}
if (max(Crossing) > ncol(Genom)){
stop("Nb of parents in crossing > Nb of parents in ParentalLineGenom")
}
if (length(ParentPop)==0){
ParentPop <- rep(1,ncol(Genom))
}
if (length(ParentPop) < max(Crossing)){
stop("Nb of parents differ between ParentPop and Crossing")
}
if (length(ParentPop) < ncol(Genom)){
stop("Nb of parents differ between ParentPop and ParentalLineGenom")
}
if (max(ParentPop) > dim(Freq)[2]){
stop("Number of Pop frequencies < number of Pop")
}
if (Phased==FALSE){
print("Argument Phased is change in TRUE")
Phased=TRUE
}
}
if (dim(Freq)[1] != dim(Genom)[1]){
stop("Nrow differs between the Genotype matrix and Pop frequencies.")
}
NbIndividual <- dim(Crossing)[1]
if(Phased==F){
NbIBD <- 9
} else {
NbIBD <- 15
}
if (length(NbCores)!=0){
if (Sys.info()[['sysname']]=="Windows"){
if (NbCores!=1){
NbCores <- 1
print("NbCores > 1 is not supported on Windows, NbCores is set to 1")
}
}
} else {
NbCores <- detectCores()-1
}
Crossing <- t(Crossing)
if (length(Combination)==0){
comb <- combn(1:NbIndividual , 2 , simplify = F)
CoupleTwoHybrids <- mclapply(comb , function(x) .RelatednessCouple(Genom[,c(Crossing[,x])],Freq,Crossing[,x],ParentPop[c(Crossing[,x])],Phased,NbInit,Prec) , mc.cores=NbCores)
CoupleOneHybridRepeted <- mclapply(1:NbIndividual , function(x) .RelatednessCouple(Genom[,c(Crossing[,c(x,x)])],Freq,Crossing[,c(x,x)],ParentPop[c(Crossing[,c(x,x)])],Phased,NbInit,Prec) , mc.cores=NbCores)
MatDelta <- sapply(CoupleTwoHybrids, function(x) x$Delta)
mat <- matrix(0,NbIndividual,NbIndividual)
DeltaTri <- lapply(1:NbIBD , function(x) .MatTriSup(mat,MatDelta[x,]))
DeltaDiag <- sapply(CoupleOneHybridRepeted, function(x) x$Delta)
Delta <- lapply(1:NbIBD , function(x) .AddDiag(DeltaTri[[x]],DeltaDiag[x,]))
names(Delta) <- paste0("Delta",1:NbIBD)
} else {
NamesCombination <- sapply(1:length(Combination) , function(x) paste0(Combination[[x]][1],"/",Combination[[x]][2]))
CoupleTwoHybrids <- mclapply(Combination , function(x) .RelatednessCouple(Genom[,c(Crossing[,x])],Freq,Crossing[,x],ParentPop[c(Crossing[,x])],Phased,NbInit,Prec) , mc.cores=NbCores)
Delta <- lapply(CoupleTwoHybrids , function(x) x$Delta)
names(Delta) <- NamesCombination
}
if (Details==TRUE){
if (Phased==TRUE){
.TheFifteenDeltaGraph()
}else{
.TheNineDeltaGraph()
}
}
return(Delta)
} |
make_option_impl <- function(getter, option_name = NULL, env = caller_env()) {
getter_body <- enexpr(getter)
if (is.null(option_name)) {
option_name <- getter_body[[2]]
stopifnot(is.character(option_name))
}
name <- sub(paste0(utils::packageName(env), "."), "", option_name, fixed = TRUE)
getter_name <- paste0("get_", utils::packageName(env), "_option_", name)
local_setter_name <- paste0("local_", utils::packageName(env), "_option_", name)
setter_name <- paste0("set_", utils::packageName(env), "_option_", name)
local_setter_body <- expr({
out <- !!call2("local_options", !!option_name := sym("value"), .frame = sym("env"))
!!call2(getter_name)
invisible(out[[1]])
})
setter_body <- expr({
out <- !!call2("options", !!option_name := sym("value"))
!!call2(getter_name)
invisible(out[[1]])
})
body <- expr({
if (missing(!!sym("value"))) {
if (!missing(local)) {
abort("Can't pass `local` argument if `value` is missing.")
}
!!getter_body
} else if (local) !!local_setter_body
else !!setter_body
})
args <- pairlist2(value = , local = FALSE, env = quote(caller_env()))
assign(getter_name, new_function(list(), getter_body, env = env), env)
assign(local_setter_name, new_function(args[c(1, 3)], local_setter_body, env = env), env)
assign(setter_name, new_function(args[1], setter_body, env = env), env)
new_function(args, body, env = env)
} |
AthenaDataType <- function(fields, ...) {
switch(
class(fields)[1],
logical = "BOOLEAN",
integer = "INT",
integer64 = "BIGINT",
numeric = "DOUBLE",
double = "DOUBLE",
factor = "STRING",
character = "STRING",
list = "STRING",
Date = "DATE",
POSIXct = "TIMESTAMP",
stop("Unknown class ", paste(class(fields), collapse = "/"), call. = FALSE)
)
}
AthenaToRDataType <- function(method, data_type) UseMethod("AthenaToRDataType")
AthenaToRDataType.athena_data.table <- function(method, data_type){
athena_to_r <- function(x){
switch(x,
boolean = "logical",
int ="integer",
integer = "integer",
tinyint = "integer",
smallint = "integer",
bigint = athena_option_env$bigint,
float = "double",
real = "double",
decimal = "double",
string = "character",
varchar = "character",
char = "character",
date = "Date",
timestamp = "POSIXct",
"timestamp with time zone" = "POSIXct",
array = "character",
row = "character",
map = "character",
json = "character",
ipaddress = "character",
varbinary = "character",
x)}
output <- vapply(data_type, athena_to_r, FUN.VALUE = character(1))
return(output)
}
AthenaToRDataType.athena_vroom <- function(method, data_type){
athena_to_r <- function(x){
switch(x,
boolean = "l",
int ="i",
integer = "i",
tinyint = "i",
smallint = "i",
bigint = athena_option_env$bigint,
double = "d",
float = "d",
real = "d",
decimal = "d",
string = "c",
varchar = "c",
char = "c",
date = "D",
timestamp = "T",
"timestamp with time zone" = "c",
array = "c",
row = "c",
map = "c",
json = "c",
ipaddress = "c",
varbinary = "c",
x)}
output <- vapply(data_type, athena_to_r, FUN.VALUE = character(1))
return(output)
} |
beta.div <- function (biom, method, weighted=TRUE, tree=NULL) {
methodList <- c("manhattan", "euclidean", "bray-curtis", "jaccard", "unifrac")
method <- methodList[pmatch(tolower(method), methodList)]
if (!is.logical(weighted)) stop(simpleError("Weighted must be TRUE/FALSE."))
if (length(method) != 1) stop(simpleError("Invalid method for beta.div()"))
if (is.na(method)) stop(simpleError("Invalid method for beta.div()"))
if (is(biom, "simple_triplet_matrix")) { counts <- biom
} else if (is(biom, "BIOM")) { counts <- biom$counts
} else if (is(biom, "matrix")) { counts <- slam::as.simple_triplet_matrix(biom)
} else {
stop(simpleError("biom must be a matrix, simple_triplet_matrix, or BIOM object."))
}
if (identical(method, "unifrac")) {
if (!is(tree, "phylo")) {
if (is(biom, "BIOM")) {
if (is(biom$phylogeny, "phylo")) {
tree <- biom$phylogeny
}
}
if (is(tree, "character")) {
if (file.exists(tree)) {
tree <- rbiom::read.tree(tree)
}
}
if (!is(tree, "phylo")) {
stop(simpleError("No tree provided to beta.div()."))
}
}
if (length(setdiff(rownames(counts), tree$tip.label)) > 0)
stop(simpleError("OTUs missing from reference tree."))
if (length(setdiff(tree$tip.label, rownames(counts))) > 0)
tree <- rbiom::subtree(tree, rownames(counts))
counts <- counts[as.character(tree$tip.label),]
}
ord <- order(counts$j, counts$i)
counts$i <- counts$i[ord]
counts$j <- counts$j[ord]
counts$v <- counts$v[ord]
if (identical(method, "unifrac")) {
par_unifrac(counts, tree, ifelse(weighted, 1L, 0L))
} else {
counts <- t(as.matrix(counts))
dm <- par_beta_div(counts, method, ifelse(weighted, 1L, 0L))
dm <- as.dist(dm)
attr(dm, 'Labels') <- rownames(counts)
return (dm)
}
} |
context("Test ra_prospect")
library(hBayesDM)
test_that("Test ra_prospect", {
skip_on_cran()
expect_output(ra_prospect(
data = "example", niter = 10, nwarmup = 5, nchain = 1, ncore = 1))
}) |
eco.phy.regression <- function(data,
randomisation=c("taxa.labels", "richness", "frequency", "sample.pool", "phylogeny.pool", "independentswap", "trialswap"), permute=0, method=c("quantile", "lm", "mantel"), indep.swap=1000, abundance=TRUE, ...){
if(! inherits(data, "comparative.comm")) stop("'data' must be a comparative community ecology object")
randomisation <- match.arg(randomisation)
method <- match.arg(method)
if(permute < 0) stop("Can't have negative null permutations!")
if(abundance==FALSE)
data$comm[data$comm>1] <- 1
eco.matrix <- as.dist(1 - as.matrix(comm.dist(data$comm)))
phy.matrix <- as.dist(cophenetic.phylo(data$phy))
observed <- .eco.phy.regression(eco.matrix, phy.matrix, method, ...)
randomisations <- vector(mode="list", length=permute)
for(i in seq(from=1, length.out=permute)){
curr.rnd <- .eco.null(data$comm, randomisation, swap.iter=indep.swap)
rnd.mat <- as.dist(1 - as.matrix(comm.dist(curr.rnd)))
if(any(is.na(rnd.mat))){
warning("NAs in permuted community matrix; skipping this iteration")
next()
}
randomisations[[i]] <- .eco.phy.regression(rnd.mat, phy.matrix, method, ...)
}
output <- .prepare.regression.output(observed, randomisations, method, permute, "eco.phy.regression")
output$data <- data
return(output)
}
.eco.phy.regression <- function(eco.mat, phy.mat, method=c("quantile", "lm", "mantel"), ...){
method <- match.arg(method)
if(method == 'lm')
model <- lm(as.numeric(eco.mat) ~ as.numeric(phy.mat), ...)
if(method == "quantile")
model <- rq(as.numeric(eco.mat) ~ as.numeric(phy.mat), ...)
if(method == "mantel")
model <- mantel(eco.mat, phy.mat, ...)
return(model)
} |
"leds.mspct" |
B <- rbind(c(1, 0, 0),
c(1, sqrt(5), 0),
c(1, 2/sqrt(5), 1/sqrt(5)))
B %*% t(B) |
"mcdermit_filters" |
dpareto.ll <- function(x, theta = NULL, ...){
th.table <- cbind(c(0,0.050,0.089,0.126,0.164,0.203,0.244,0.286,0.332,0.380,
0.431,0.486,0.545,0.609,0.678,0.753,0.835,0.925,1.025,1.135,
1.258,1.395,1.549,1.723,1.921,2.146,2.404,2.701,3.044,3.442,
3.904,4.442,5.071,5.807,6.669,7.682,8.870),seq(0,.36,by=.01))
inf.test <- which(x==Inf)
if(length(inf.test)>0){
x[inf.test] <- max(x[-inf.test])
warning("Values of x equal to 'Inf' are set to the maximum finite value.",call.=FALSE)
}
x.bar <- mean(x)
if(is.null(theta)){
if(x.bar<=max(th.table[,1])){
ind <- max(which(th.table[,1]<x.bar))
theta <- approx(th.table[ind:(ind+1),],xout=x.bar)$y
} else{
S.hat <- sapply(1:length(x),function(i) mean(x>=x[i]))
theta <- prod(S.hat^((sum(log(1+x)))^(-1)))
}
}
tmp <- which(ddpareto(x,theta=theta,log=TRUE)==-Inf)
if(length(tmp)>0){
x[tmp] <- max(x[-tmp])
warning("Numerical overflow problem when calculating log-density of some x values. The problematic values are set to the maximum finite value calculated.",call.=FALSE)
}
ll.f <- function(theta) -sum(ddpareto(x,theta=theta,log=TRUE))
fit <- try(suppressWarnings(stats4::mle(ll.f,start=list(theta=theta),lower=0,upper=1,method="Brent")),silent=TRUE)
if(class(fit)=="try-error") stop(paste("Numerical optimization of the MLE failed. Consider trying a different starting value for theta.","\n"))
fit
} |
`TDiM` <-
function(S,R){
N<-length(S)
(1/sqrt(N-1))*(sum(S*R) - N*mean(S)*mean(R))/(sd(S)*sd(R))
} |
HDistSize <- function(b1,b2,n2){
b2c <- c(b1,b2)
b2min <- min(b2c)
b2max <- max(b2c)
P1 <- density(b1,from=b2min,to=b2max,n=n2)
Q1 <- density(b2,from=b2min,to=b2max,n=n2)
Pdiff1 <- P1$y
Qdiff1 <- Q1$y
step1 <- P1$x[2]-P1$x[1]
diver1 <- (sqrt(Pdiff1)-sqrt(Qdiff1))^2*step1
res1 <- sqrt(sum(diver1)/2)
return(res1)
}
NULL
NULL
NULL
NULL
NULL |
"c30_df" |
eqv.ssd <- function(conc, time, group, dependent=FALSE, method=c("fieller", "z", "boott"), conf.level=0.90, strata=NULL, nsample=1000, data){
auc <- function(conc, time){
xq <- tapply(conc, time, mean)
sxq <- tapply(conc, time, var) / tapply(conc, time, length)
est <- sum(.weight(time)*xq)
var <- sum(.weight(time)^2*sxq)
return(list(est=est, var=var))
}
asymp <- function(data1, data2, alpha){
auc1 <- auc(data1$conc, data1$time)
auc2 <- auc(data2$conc, data2$time)
auc1$var <- auc1$var
auc2$var <- auc2$var
var.asymp <- auc1$var/(auc2$est^2) + (auc1$est^2)/(auc2$est^4)*auc2$var
z <- qnorm(p=1-alpha/2, mean=0, sd=sqrt(1))
est <- auc1$est / auc2$est
lower <- est - z*sqrt(var.asymp)
upper <- est + z*sqrt(var.asymp)
res <- c(lower, upper)
return(res)
}
boott <- function(data1, data2, alpha, nsample, bystrata1, bystrata2){
obsv.auc1 <- auc(data1$conc, data1$time)
obsv.auc2 <- auc(data2$conc, data2$time)
obsv.est <- obsv.auc1$est / obsv.auc2$est
obsv.var <- obsv.auc1$var/(obsv.auc2$est^2) + (obsv.auc1$est^2)/(obsv.auc2$est^4)*obsv.auc2$var
boot.stat <- rep(NA,nsample)
for(i in 1:nsample){
boot.data1 <- data.frame(time=data1$time, conc=unlist(tapply(data1$conc, bystrata1, sample, replace=TRUE)), stringsAsFactors = TRUE)
boot.data2 <- data.frame(time=data2$time, conc=unlist(tapply(data2$conc, bystrata2, sample, replace=TRUE)), stringsAsFactors = TRUE)
boot.auc1 <- auc(boot.data1$conc, boot.data1$time)
boot.auc2 <- auc(boot.data2$conc, boot.data2$time)
boot.est <- boot.auc1$est / boot.auc2$est
boot.var <- boot.auc1$var/(boot.auc2$est^2) + (boot.auc1$est^2)/(boot.auc2$est^4)*boot.auc2$var
boot.stat[i] <- (boot.est - obsv.est) / sqrt(boot.var)
}
t.lb <- quantile(boot.stat, probs=c(alpha/2), method=5, na.rm=TRUE)
t.ub <- quantile(boot.stat, probs=c(1-alpha/2), method=5, na.rm=TRUE)
base <- data.frame(est=obsv.est, t.lb=t.lb, t.ub=t.ub, stringsAsFactors = TRUE)
base$lower <- base$est - base$t.ub*sqrt(obsv.var)
base$upper <- base$est - base$t.lb*sqrt(obsv.var)
return(c(base$lower, base$upper))
}
if(!missing(data)){
cnames <- colnames(data)
if(!any(cnames=='conc')){stop("data does not contain a variable conc")}
if(!any(cnames=='time')){stop("data does not contain a variable time")}
conc <- data$conc
time <- data$time
if(any(cnames=='group')){
group <- data$group
}
}
method <- match.arg(method, several.ok=TRUE)
method <- sort(method)
if(length(conc) != length(time)){stop('different length of input vectors')}
if(!is.null(strata)){
if(length(conc)!=length(strata)){stop('different length of input vectors')}
if(method!='boott'){warning("strata variable only applicable in method boott")}
}
if(!is.null(group)){
if(length(conc)!=length(group)){stop('different length of input vectors')}
if(length(unique(group))!=2){stop("limited for comparison of 2 groups")}
}
data <- data.frame(conc=conc, time=time, stringsAsFactors = TRUE)
if(is.null(strata)){strata <- rep(1, nrow(data))}
data <- cbind(data, group=as.factor(group), strata=as.factor(strata))
data <- na.omit(data[order(data$strata, data$group, data$time),])
grpfact <- levels(data$group)
if(any(na.omit(as.vector(tapply(data$conc, list(data$strata, data$group, data$time), length))) < 2)){
stop('at least 2 observations per strata, group and time point required')
}
if(any(method=='boott')){
bystrata <- data.frame(time, group, strata, stringsAsFactors = TRUE)
bystrata <- bystrata[order(bystrata$group, bystrata$strata, bystrata$time),]
bystrata1 <- as.list(subset(bystrata, bystrata$group==grpfact[1]))
bystrata2 <- as.list(subset(bystrata, bystrata$group==grpfact[2]))
}
alpha <- 1-conf.level
w1 <- .weight(unlist(subset(data, data$group==grpfact[1], select='time')))
w2 <- .weight(unlist(subset(data, data$group==grpfact[2], select='time')))
if(length(w1) != length(w2) || !all(w1==w2)){stop('time points are not identical for both groups')}
w <- .weight(data$time)
data1 <- subset(data, data$group==grpfact[1])
data2 <- subset(data, data$group==grpfact[2])
auc1 <- auc.ssd(conc=data1$conc,data1$time,method='t',conf.level=conf.level)
auc2 <- auc.ssd(conc=data2$conc,data2$time,method='t',conf.level=conf.level)
n1 <- tapply(data1$conc, data1$time, length)
n2 <- tapply(data2$conc, data2$time, length)
sd1 <- tapply(data1$conc, data1$time, sd)
sd2 <- tapply(data2$conc, data2$time, sd)
est <- auc1$est/auc2$est
num <- (sum(w^2*sd1^2*n1^-1) + est^2*sum(w^2*sd2^2*n2^-1))^2
den <- sum(w^4*sd1^4*(n1^2*(n1-1))^-1) + est^4*sum(w^4*sd2^4*(n2^2*(n2-1))^-1)
df.fieller <- num/den
sd1 <- auc1$CIs[1,2]
sd2 <- auc2$CIs[1,2]
var.asymp <- sd1^2/(auc2$est^2) + (auc1$est^2)/(auc2$est^4)*sd2^2
res <- NULL
df <- NULL
if(any(method=='boott')){
res <- rbind(res, boott(data1=data1, data2=data2, alpha=alpha, nsample=nsample, bystrata1=bystrata1, bystrata2=bystrata2))
df <- rbind(df,NA)
}
if(any(method=='fieller')){
res <- rbind(res,res <- .fieller.ind(auc1=auc1$est, auc2=auc2$est, var1=sd1^2, var2=sd2^2, df=df.fieller, conf.level=conf.level))
df <- rbind(df,df.fieller)
}
if(any(method=='z')){
res <- rbind(res,asymp(data1=data1, data2=data2, alpha=alpha))
df <- rbind(df,NA)
}
rownames(res) <- method
rownames(df) <- method
colnames(res) <- c('lower','upper')
out <- NULL
out$est <- matrix(as.double(est),ncol=1)
rownames(out$est) <- 'ratio of independent AUCs to tlast'
colnames(out$est) <- 'est'
out$CIs<-data.frame(est=rep(est,length(method)), stderr=rep(sqrt(var.asymp),length(method)), lower=res[,1], upper=res[,2], df=df ,method=method, stringsAsFactors = TRUE)
rownames(out$CIs) <- paste(conf.level*100,'% CI using a ', method,'-interval for the ratio of independent AUCs to tlast', sep='')
out$design<-"ssd"
out$conf.level <- conf.level
out$conc <- conc
out$time <- time
out$group <- group
class(out)<-"PK"
return(out)
} |
"abundances" |
rectangleSP_test <- function (x0, y0, w, h) {
x = c(x0 + w/2, x0 - w/2, x0 - w/2, x0 + w/2)
y = c(y0 + h/2, y0 + h/2, y0 - h/2, y0 - h/2)
x = c(x, x[1])
y = c(y, y[1])
return(sp::SpatialPolygons(list(sp::Polygons(list(with(list(x = x, y = y),
sp::Polygon(cbind(x,y)))),1))) )
} |
fitG <- function(x, verbose = 'v') {
t0 <- Sys.time()
out <- fitG_mle(x, verbose)
out$call <- match.call()
out$x <- x
out$time <- Sys.time() - t0
out$n <- length(x)
out$k <- 3
out$df <- out$n - 3
depo <- with(out,
is_GHvalid(estimate[1], estimate[2], estimate[3], 0)
)
if (is.character(depo)) {
out$loglik <- NA
} else {
out$loglik <- loglikG(out$estimate, x)
out$AIC <- 2 * out$df - 2 * out$loglik
out$BIC <- out$df * log(out$n) - 2 * out$loglik
}
return(out)
}
fitG_mle <- function(x, verbose) {
vmessage(verbose, 1, TRUE, 'Maximum likelihood fitting')
vmessage(verbose, 2, TRUE, 'Initialisation...')
out <- new_fitGH()
fitGH_hoaglin1985(x) %>%
use_series('estimate') %>%
unname -> init
xst <- (x - init[1]) / init[2]
vmessage(verbose, 2, TRUE, 'Estimation...')
depo <- nlm(
f = function(theta, xdata) { -loglikG(c(0, 1, theta), xdata) },
p = mean(c(1 / max(xst), -1 / min(xst))),
xdata = xst
)
vmessage(verbose, 2, TRUE, 'Preparing output...')
out$distr <- 'g'
out$method <- 'mle'
out$textmethod <- 'Maxmimum likelihood'
out$estimate[1:4] <- c(init[1:2], depo$estimate, 0)
out$estimator <- depo
vmessage(verbose, 1, TRUE, 'Done!')
return(out)
}
print.fitG <- function(x, ...) {
cat('\nCall:\n')
print(x$call)
cat('\nPoint estimates:\n')
print(x$estimate)
invisible(x)
}
coef.fitG <- function(object, ...) { object$estimate }
summary.fitG <- function(object, ...) {
cat('\nFitted', toupper(object$distr), 'distribution\n')
cat('\nCall:\n')
print(object$call)
cat('\nParameters:\n\n')
depo <- as.matrix(object$estimate)
colnames(depo) <- 'Estimate'
rownames(depo) %<>% paste0(' ')
print(signif(depo, 4))
cat('\n',
'Fitting method: ', object$textmethod, ', ',
'Computation time: ', signif(object$time, 3), ' ', units(object$time), '\n',
'Observations: ', object$n, ', degrees of freedom: ', object$df,
ifelse(
test = is.na(object$loglik),
yes = '',
no = paste0(
', Log-lik: ', format(object$loglik), '\n', 'AIC: ',
format(object$AIC), ', ', 'BIC: ', format(object$BIC)
)
), '\n', sep = ''
)
invisible(object)
} |
stat_density_ridges <- function(mapping = NULL, data = NULL, geom = "density_ridges",
position = "identity", na.rm = FALSE, show.legend = NA,
inherit.aes = TRUE, bandwidth = NULL, from = NULL, to = NULL,
jittered_points = FALSE, quantile_lines = FALSE, calc_ecdf = FALSE, quantiles = 4,
quantile_fun = quantile, n = 512, ...)
{
layer(
stat = StatDensityRidges,
data = data,
mapping = mapping,
geom = geom,
position = position,
show.legend = show.legend,
inherit.aes = inherit.aes,
params = list(bandwidth = bandwidth,
from = from,
to = to,
calc_ecdf = calc_ecdf,
quantiles = quantiles,
jittered_points = jittered_points,
quantile_lines = quantile_lines,
quantile_fun = quantile_fun,
n = n,
na.rm = na.rm, ...)
)
}
StatDensityRidges <- ggproto("StatDensityRidges", Stat,
required_aes = "x",
default_aes = aes(height = ..density..),
calc_panel_params = function(data, params) {
if (is.null(params$bandwidth)) {
xdata <- na.omit(data.frame(x=data$x, group=data$group))
xs <- split(xdata$x, xdata$group)
xs_mask <- vapply(xs, length, numeric(1)) > 1
bws <- vapply(xs[xs_mask], bw.nrd0, numeric(1))
bw <- mean(bws, na.rm = TRUE)
message("Picking joint bandwidth of ", signif(bw, 3))
params$bandwidth <- bw
}
if (is.null(params$from)) {
params$from <- min(data$x, na.rm=TRUE) - 3 * params$bandwidth
}
if (is.null(params$to)) {
params$to <- max(data$x, na.rm=TRUE) + 3 * params$bandwidth
}
data.frame(
bandwidth = params$bandwidth,
from = params$from,
to = params$to
)
},
setup_params = function(self, data, params) {
panels <- split(data, data$PANEL)
pardata <- lapply(panels, self$calc_panel_params, params)
pardata <- reduce(pardata, rbind)
if (length(params$quantiles) > 1 &&
(max(params$quantiles, na.rm = TRUE) > 1 || min(params$quantiles, na.rm = TRUE) < 0)) {
stop('invalid quantiles used: c(', paste0(params$quantiles, collapse = ','), ') must be within [0, 1] range')
}
params$bandwidth <- pardata$bandwidth
params$from <- pardata$from
params$to <- pardata$to
params
},
compute_group = function(data, scales, from, to, bandwidth = 1,
calc_ecdf = FALSE, jittered_points = FALSE, quantile_lines = FALSE,
quantiles = 4, quantile_fun = quantile, n = 512) {
if(nrow(data) < 3) return(data.frame())
if (is.null(calc_ecdf)) calc_ecdf <- FALSE
if (is.null(jittered_points)) jittered_points <- FALSE
if (is.null(quantile_lines)) quantile_lines <- FALSE
if (quantile_lines) calc_ecdf <- TRUE
panel <- unique(data$PANEL)
if (length(panel) > 1) {
stop("Error: more than one panel in compute group; something's wrong.")
}
panel_id <- as.numeric(panel)
d <- stats::density(
data$x,
bw = bandwidth[panel_id], from = from[panel_id], to = to[panel_id], na.rm = TRUE,
n = n
)
maxdens <- max(d$y, na.rm = TRUE)
densf <- approxfun(d$x, d$y, rule = 2)
if (jittered_points) {
df_jittered <- data.frame(
x = data$x,
density = densf(data$x),
ndensity = densf(data$x) / maxdens,
datatype = "point", stringsAsFactors = FALSE)
df_points <- data[grepl("point_", names(data))]
if (ncol(df_points) == 0) {
df_points <- NULL
df_points_dummy <- NULL
}
else {
df_jittered <- cbind(df_jittered, df_points)
df_points_dummy <- na.omit(df_points)[1, , drop = FALSE]
}
} else {
df_jittered <- NULL
df_points_dummy <- NULL
}
if ((length(quantiles)==1) && (all(quantiles >= 1))) {
if (quantiles > 1) {
probs <- seq(0, 1, length.out = quantiles + 1)[2:quantiles]
}
else {
probs <- NA
}
} else {
probs <- quantiles
probs[probs < 0 | probs > 1] <- NA
}
qx <- na.omit(quantile_fun(data$x, probs = probs))
df_quantiles <- NULL
if (quantile_lines && length(qx) > 0) {
qy <- densf(qx)
df_quantiles <- data.frame(
x = qx,
density = qy,
ndensity = qy / maxdens,
datatype = "vline",
stringsAsFactors = FALSE
)
if (!is.null(df_points_dummy)){
df_quantiles <- data.frame(df_quantiles, as.list(df_points_dummy))
}
}
df_nondens <- rbind(df_quantiles, df_jittered)
if (calc_ecdf) {
n <- length(d$x)
ecdf <- c(0, cumsum(d$y[1:(n-1)]*(d$x[2:n]-d$x[1:(n-1)])))
ecdf_fun <- approxfun(d$x, ecdf, rule = 2)
ntile <- findInterval(d$x, qx, left.open = TRUE) + 1
if (!is.null(df_nondens)) {
df_nondens <- data.frame(
df_nondens,
ecdf = ecdf_fun(df_nondens$x),
quantile = findInterval(df_nondens$x, qx, left.open = TRUE) + 1
)
}
df_density <- data.frame(
x = d$x,
density = d$y,
ndensity = d$y / maxdens,
ecdf = ecdf,
quantile = ntile,
datatype = "ridgeline",
stringsAsFactors = FALSE
)
}
else {
df_density <- data.frame(
x = d$x,
density = d$y,
ndensity = d$y / maxdens,
datatype = "ridgeline",
stringsAsFactors = FALSE
)
}
if (!is.null(df_points_dummy)){
df_density <- data.frame(df_density, as.list(df_points_dummy))
}
df_final <- rbind(df_density, df_nondens)
if ("quantile" %in% names(df_final)) {
df_final$quantile <- factor(df_final$quantile)
}
df_final
}
)
stat_binline <- function(mapping = NULL, data = NULL,
geom = "density_ridges", position = "identity",
...,
binwidth = NULL,
bins = NULL,
center = NULL,
boundary = NULL,
breaks = NULL,
closed = c("right", "left"),
pad = TRUE,
draw_baseline = TRUE,
na.rm = FALSE,
show.legend = NA,
inherit.aes = TRUE) {
layer(
data = data,
mapping = mapping,
stat = StatBinline,
geom = geom,
position = position,
show.legend = show.legend,
inherit.aes = inherit.aes,
params = list(
binwidth = binwidth,
bins = bins,
center = center,
boundary = boundary,
breaks = breaks,
closed = closed,
pad = pad,
draw_baseline = draw_baseline,
na.rm = na.rm,
...
)
)
}
StatBinline <- ggproto("StatBinline", StatBin,
required_aes = "x",
default_aes = aes(height = ..density..),
setup_params = function(data, params) {
if (is.null(params$pad)) {
params$pad <- TRUE
}
if (is.null(params$draw_baseline)) {
params$draw_baseline <- TRUE
}
if (!is.null(params$boundary) && !is.null(params$center)) {
stop("Only one of `boundary` and `center` may be specified.", call. = FALSE)
}
if (is.null(params$breaks) && is.null(params$binwidth) && is.null(params$bins)) {
message("`stat_binline()` using `bins = 30`. Pick better value with `binwidth`.")
params$bins <- 30
}
params
},
compute_group = function(self, data, scales, binwidth = NULL, bins = NULL,
center = NULL, boundary = NULL,
closed = c("right", "left"), pad = TRUE,
breaks = NULL, origin = NULL, right = NULL,
drop = NULL, width = NULL, draw_baseline = TRUE) {
binned <- ggproto_parent(StatBin, self)$compute_group(data = data,
scales = scales, binwidth = binwidth,
bins = bins, center = center, boundary = boundary,
closed = closed, pad = pad, breaks = breaks)
result <- rbind(transform(binned, x=xmin), transform(binned, x=xmax-0.00001*width))
result <- result[order(result$x), ]
if (!draw_baseline) {
zeros <- result$count == 0
protected <- (zeros & !c(zeros[2:length(zeros)], TRUE)) | (zeros & !c(TRUE, zeros[1:length(zeros)-1]))
to_remove <- zeros & !protected
result$count[to_remove] <- NA
result$density[to_remove] <- NA
}
result
}
) |
skip_on_cran()
library("adea")
demo("cardealers")
test_that("cardealers demo", {
expect_s3_class(sol.adea, "adea")
expect_equal(sol.adea$load$load, 0.66666667)
expect_equal(names(sol.adea$load$iinput), c("Employees"))
expect_s3_class(sol.ah, "adeahierarchical")
expect_equal(length(sol.ah$models), 4)
expect_equal(sol.ah$models[[4]]$load$load, 0.66666667)
expect_equal(names(sol.ah$models[[4]]$load$iinput), c("Employees"))
expect_s3_class(sol.ap, "adeaparametric")
expect_equal(length(sol.ap$models), 4)
expect_equal(sol.ap$models[[4]]$load$load, 0.66666667)
expect_equal(names(sol.ap$models[[4]]$load$iinput), c("Employees"))
})
demo("spanishuniversities2018")
test_that("spanishuniversities2018 demo", {
expect_s3_class(sol.dea, "Farrell")
expect_equal(sol.dea$eff[1], 0.77542788)
expect_equal(sol.dea$ux[1], 0.00091240876)
expect_s3_class(sol.adea, "adea")
expect_equal(sol.adea$load$load, 0.58985841)
expect_equal(as.numeric(sol.adea$load$ratios$output[7]), 0.75717137)
})
demo("tokyo_libraries")
test_that("cardealers demo", {
expect_s3_class(sol.adea, "adea")
expect_equal(sol.adea$load$load, 0.455467)
expect_equal(names(sol.adea$load$iinput), c("Area.I1"))
expect_s3_class(sol.adea, "adea")
expect_equal(sol.adea$load$load, 0.455467)
expect_equal(names(sol.adea$load$iinput), c("Area.I1"))
}) |
sbpr<-function(age=NULL,ssbwgt=NULL,partial=NULL,pmat=pmat,M=NULL,pF=NULL, pM=NULL,MSP=40,plus=FALSE,oldest=NULL,maxF=2,incrF=0.0001,graph=TRUE){
if(is.null(age))
stop ("age vector is missing")
if(is.null(ssbwgt))
stop (" ssbwgt vector is missing.")
if(is.null(partial))
stop ("partial recruitment vector is missing.")
if(is.null(pmat))
stop ("pmat vector is missing.")
if(is.null(M))
stop ("M value or vector is missing")
if(is.null(pF))
stop ("pF value is missing.")
if(is.null(pM))
stop ("pM value is missing.")
if(plus==TRUE & is.null(oldest)) stop("oldest must be specified for plus group calculation.")
if(any(length(age)!=c(length(age),length(ssbwgt),length(partial),length(pmat))))
stop("Length of vectors unequal")
if(length(M)==1) M<-rep(M,length(age))
data<-as.data.frame(cbind(age,ssbwgt,partial,M,pmat,pF,pM))
SPR<-as.data.frame(cbind(rep(NA,ceiling(maxF/incrF)+1),
rep(NA,ceiling(maxF/incrF)+1)))
names(SPR)<-c("F","SPR")
if(plus==TRUE){
len<-oldest-min(data$age)+1
if(oldest>max(data$age)){
pdata<-data[rep(length(data$age),times=oldest-data$age[length(data$age)]), ]
pdata$age<-seq(max(data$age)+1,oldest,1)
data<-rbind(data,pdata)}
}
if(plus==FALSE) len<-max(data$age)-min(data$age)+1
F<-0
for (i in 1:length(SPR$F))
{
data$SB<-exp(-(data$partial*data$pF*F+data$pM*data$M))
data$S<-cumprod(exp(-(data$partial*F+data$M)))
data$psb[1]<-1
for(y in 2:len)
{
data$psb[y]<-data$S[y-1]
}
data$SPR<-data$psb*data$SB*data$ssbwgt*data$pmat
SPR$SPR[i]<-sum(data$SPR)
SPR$F[i]<-F
F<-F+incrF
}
SPR$PSPR<-SPR$SPR/SPR$SPR[1]*100
sss<-NULL
getF<-function(x){
data$SB<-exp(-(data$partial*data$pF*x+data$pM*data$M))
data$S<-cumprod(exp(-(data$partial*x+data$M)))
data$psb[1]<-1
for(y in 2:len)
{
data$psb[y]<-data$S[y-1]
}
data$SPR<-data$psb*data$SB*data$ssbwgt*data$pmat
sss<<-sum(data$SPR)
return(((sum(data$SPR)/SPR$SPR[1]*100)-MSP)^2)
}
Fsp<-optimize(getF,c(0,maxF),tol=0.0000001)[1]
ans<-NULL
ans<-matrix(NA,1L,2L)
ans<-rbind(cbind(Fsp,sss))
dimnames(ans)<-list(c(paste("F at ",MSP,"%MSP",sep="")),c("F","SSB_Per_Recruit"))
outpt<-list(ans,SPR);names(outpt)<-c("Reference_Point","F_vs_SPR")
if(graph==TRUE){
par(mfrow=c(1,2))
plot(SPR[,2]~SPR[,1],ylab="SPR",xlab="F",type="l")
plot(SPR[,3]~SPR[,1],ylab="% Max SPR",xlab="F",type="l")
}
return(outpt)
} |
WrapKrigSpTi <- function(
WrapSpTi_out,
coords_obs,
coords_nobs,
times_obs,
times_nobs,
x_obs
)
{
pp <- unlist(WrapSpTi_out)
sigma2 <- as.numeric(pp[regexpr("sigma2",names(pp)) == 1])
alpha <- as.numeric(pp[regexpr("alpha",names(pp)) == 1])
rho_sp <- as.numeric(pp[regexpr("rho_sp",names(pp)) == 1])
rho_t <- as.numeric(pp[regexpr("rho_t",names(pp)) == 1])
sep_par <- as.numeric(pp[regexpr("sep_par",names(pp)) == 1])
row.k <- nrow(WrapSpTi_out[[1]]$k)
pp2 <- as.numeric(pp[regexpr("k",names(pp)) == 1])
k <- matrix(pp2,nrow = row.k)
rm(pp,pp2)
MeanCirc <- atan2(sum(sin(x_obs)),sum(cos(x_obs)))
x_obs <- (x_obs - MeanCirc + pi) %% (2*pi)
alpha <- (alpha + MeanCirc - pi) %% (2*pi)
n <- nrow(k)
nprev <- nrow(coords_nobs)
nsample <- ncol(k)
H_tot <- as.matrix(stats::dist(rbind(coords_obs,coords_nobs)))
Ht_tot <- as.matrix(stats::dist(c(times_obs,times_nobs)))
out <- WrapKrigSpTiCpp(sigma2, alpha, rho_sp, rho_t,sep_par, k,
n, nsample, H_tot, Ht_tot, nprev, x_obs)
out$Prev_out <- (out$Prev_out - pi + MeanCirc) %% (2*pi)
out$M_out <- (out$M_out - pi + MeanCirc) %% (2*pi)
return(out)
} |
context("&& and ||")
test_that("&& works well", {
f <- function() { FALSE && TRUE }
expect_equal(cyclocomp(f), 2)
})
test_that("|| works well", {
f <- function() { FALSE || TRUE }
expect_equal(cyclocomp(f), 2)
}) |
source("setup/setup.R")
library(dm)
flights_dm <- dm_nycflights13()
tbl(flights_dm, "airports")
flights_dm$planes
flights_dm[["weather"]]
dm_apply_filters_to_tbl(flights_dm, airlines) |
get_nns_ratio <- function(x,
N = 10,
groups,
numerator = NULL,
candidates = character(0),
pre_trained,
transform = TRUE,
transform_matrix,
bootstrap = TRUE,
num_bootstraps = 10,
permute = TRUE,
num_permutations = 100,
verbose = TRUE){
if(class(x)[1] != "tokens") stop("data must be of class tokens")
group_vars <- unique(groups)
if(is.null(group_vars) | length(group_vars)!=2) stop("a binary grouping variable must be provided")
if(!is.null(numerator)){
if(!(numerator %in% group_vars)) stop("numerator must refer to one of the two groups in the groups argument")
}
denominator <- setdiff(group_vars, numerator)
if(!is.null(groups)) quanteda::docvars(x) <- NULL; quanteda::docvars(x, "group") <- groups
x_dfm <- quanteda::dfm(x, tolower = FALSE)
x_dem <- dem(x = x_dfm, pre_trained = pre_trained, transform = transform, transform_matrix = transform_matrix, verbose = FALSE)
wvs <- dem_group(x = x_dem, groups = x_dem@docvars$group)
if(length(candidates) > 0) candidates <- intersect(candidates, rownames(pre_trained))
nnsdfs <- nns(x = wvs, N = Inf, candidates = candidates, pre_trained = pre_trained, as_list = TRUE)
nnsdf1 <- if(is.null(N)) nnsdfs[[numerator]]$feature else nnsdfs[[numerator]]$feature[1:N]
nnsdf2 <- if(is.null(N)) nnsdfs[[denominator]]$feature else nnsdfs[[denominator]]$feature[1:N]
union_nns <- union(nnsdf1, nnsdf2)
if(!bootstrap){
result <- nns_ratio(x = wvs, N = N, numerator = numerator, candidates = union_nns, pre_trained = pre_trained)
}else{
cat('starting bootstraps \n')
nnsratiodf_bs <- replicate(num_bootstraps,
nns_ratio_boostrap(x = x,
groups = groups,
numerator = numerator,
candidates = union_nns,
pre_trained = pre_trained,
transform = transform,
transform_matrix = transform_matrix),
simplify = FALSE)
result <- do.call(rbind, nnsratiodf_bs) %>%
dplyr::group_by(feature) %>%
dplyr::summarise(std.error = sd(value),
value = mean(value),
.groups = 'keep') %>%
dplyr::ungroup() %>%
dplyr::select('feature','value', 'std.error') %>%
dplyr::arrange(-value)
cat('done with bootstraps \n')
}
if(permute){
cat('starting permutations \n')
permute_out <- replicate(num_permutations, nns_ratio_permute(x,
groups = groups,
numerator = numerator,
candidates = union_nns,
pre_trained = pre_trained,
transform = transform,
transform_matrix = transform_matrix),
simplify = FALSE)
dev1 <- result %>% dplyr::mutate(value = abs(value - 1)) %>% as.data.frame()
dev1_perm <- lapply(permute_out, function(perm) perm[order(match(perm[,1],dev1[,1])),'value'])
dev1_perm <- do.call(rbind, dev1_perm)
dev1_perm <- abs(dev1_perm - 1)
dev1_perm <- apply(dev1_perm, 1, function(i) i >= dev1$value)
p.value <- apply(dev1_perm, 1, function(i) sum(i)/length(i))
result <- result %>% dplyr::mutate(p.value = p.value)
cat('done with permutations \n')
}
result <- result %>% dplyr::mutate(group = dplyr::case_when((feature %in% nnsdf1) & (feature %in% nnsdf2) ~ "shared",
(feature %in% nnsdf1) & !(feature %in% nnsdf2) ~ numerator,
!(feature %in% nnsdf1) & (feature %in% nnsdf2) ~ denominator))
attr(result, "numerator") <- numerator
if(verbose) cat("NOTE: values refer to the ratio", paste0(numerator, "/", denominator, "."))
return(result)
}
nns_ratio_boostrap <- function(x,
groups,
numerator = NULL,
candidates = character(0),
pre_trained = pre_trained,
transform = TRUE,
transform_matrix = transform_matrix){
x <- quanteda::tokens_sample(x = x, size = table(groups), replace = TRUE, by = groups)
x_dfm <- quanteda::dfm(x, tolower = FALSE)
x_dem <- dem(x = x_dfm, pre_trained = pre_trained, transform = transform, transform_matrix = transform_matrix, verbose = FALSE)
wvs <- dem_group(x = x_dem, groups = x_dem@docvars$group)
result <- nns_ratio(x = wvs, N = NULL, numerator = numerator, candidates = candidates, pre_trained = pre_trained, verbose = FALSE)
return(result)
}
nns_ratio_permute <- function(x,
groups,
numerator = NULL,
candidates = character(0),
pre_trained,
transform = TRUE,
transform_matrix){
quanteda::docvars(x, 'group') <- sample(groups)
x_dfm <- quanteda::dfm(x, tolower = FALSE)
x_dem <- dem(x = x_dfm, pre_trained = pre_trained, transform = transform, transform_matrix = transform_matrix, verbose = FALSE)
wvs <- dem_group(x = x_dem, groups = x_dem@docvars$group)
result <- nns_ratio(x = wvs, N = NULL, numerator = numerator, candidates = candidates, pre_trained = pre_trained, verbose = FALSE)
return(result)
} |
SampDist2Props <-
function(form,data,max.sample.sizes=100,sim.reps=1000) {
if (!("manipulate" %in% installed.packages())) {
return(cat(paste0("You must be on R Studio with package manipulate installed\n",
"in order to run this function.")))
}
data <- data[complete.cases(data),]
prsd <- with(data,ParseFormula(form))
Explanatory.Variable <- as.character(prsd$rhs)[2]
Response.Variable <- as.character(prsd$rhs)[3]
breaker <- data[,Explanatory.Variable]
respvals <- data[,Response.Variable]
twopops <- split(respvals,breaker)
pop1 <- twopops[[1]]
pop2 <- twopops[[2]]
explanatory <- breaker
response <- respvals
results <- table(explanatory,response)
print(results)
cat("\n")
N1 <- sum(results[1,])
N2 <- sum(results[2,])
p1 <- results[1,1]/N1
p2 <- results[2,1]/N2
if (max.sample.sizes>min(N1,N2)) {
stop("Desired sample sizes must be less than pop sizes: choose lower value for max.sample.sizes argument.")
}
manipulate(
n1=slider(1,max.sample.sizes,initial=1,label="Sample Size n1"),
n2=slider(1,max.sample.sizes,initial=1,label="Sample Size n2"),
curvetype=picker("None","Density Estimate","Theoretical Normal"),
{
big <- max.sample.sizes
sddiffprops <- sqrt(p1*(1-p1)/n1*(N1-n1)/(N1-1)+p2*(1-p2)/n2*(N2-n2)/(N2-1))
minsddiffprops <- sqrt(p1*(1-p1)/big*(N1-big)/(N1-1)+p2*(1-p2)/big*(N2-big)/(N2-1))
ymax <- 1.2/(sqrt(2*3.1416)*minsddiffprops)
reps <- sim.reps
sim.pdiffs <- numeric(reps)
for (i in 1:reps) {
samp1 <- sample(pop1,n1,replace=FALSE)
res.1 <- table(samp1)
samp2 <- sample(pop2,n2,replace=FALSE)
res.2 <- table(samp2)
sim.pdiffs[i] <- res.1[1]/n1-res.2[1]/n2
}
hist(sim.pdiffs,freq=FALSE,xlim=c(-1,1),
xlab=expression(hat(p)[1]-hat(p)[2]),
ylim=c(0,ymax),
col="blue",
main=paste(reps,"simulations"))
if(curvetype=="Density Estimate") {
d <- density(sim.pdiffs)
lines(d$x,d$y,col="red")
}
if (curvetype=="Theoretical Normal") {
curve(dnorm(x,mean=(p1-p2),sd=sddiffprops),
xlim=c(-1,1),add=TRUE,col="red",n=1001)
}
quantities <- c("p1-p2","expected value of p1hat-p2hat","stdev of p1hat-p2hat")
theoretical <-c(p1-p2,p1-p2,sddiffprops)
in.simulation <- c(NA,mean(sim.pdiffs),sd(sim.pdiffs))
frm <- data.frame(theoretical,in.simulation)
rownames(frm) <- quantities
print(frm)
cat("\n")
}
)
}
if(getRversion() >= "2.15.1") utils::globalVariables(c("picker", "curvetype","n1","n2")) |
resource_specialisation_case <- function(eventlog) {
freq <- NULL
nr_of_activity_types <- NULL
eventlog %>%
group_by(!!resource_id_(eventlog), !!activity_id_(eventlog), !!case_id_(eventlog)) %>%
summarize() %>%
group_by(!!case_id_(eventlog)) %>%
mutate(nr_of_activity_types = n_distinct(!!activity_id_(eventlog))) %>%
group_by(!!case_id_(eventlog), nr_of_activity_types, !!resource_id_(eventlog)) %>%
summarize(freq = n()) %>%
grouped_summary_statistics("freq")
} |
.refit <- function(object, fitting.method = "quadratic", jackknife.estimation = "quadratic",
asymptotic = TRUE, allowed.fitting = c("quad", "line", "nonl", "logl",
"log2"), allowed.jackknife = c("quad", "line", "nonl", "logl",
FALSE), ...) {
fitting.method <- substr(fitting.method, 1, 4)
if (object$fitting.method == fitting.method)
stop("Model is already fitted with the specified fitting method",
call. = FALSE)
if (!any(fitting.method == allowed.fitting)) {
warning("Fitting method not implemented. Using: quadratic", call. = FALSE)
fitting.method <- "quad"
}
if (jackknife.estimation != FALSE)
jackknife.estimation <- substr(jackknife.estimation, 1, 4)
if (!any(jackknife.estimation == allowed.jackknife)) {
warning("Fitting method (jackknife) not implemented. Using: quadratic",
call. = FALSE)
jackknife.estimation <- "quad"
}
if (!any(names(object) == "variance.jackknife") && jackknife.estimation !=
FALSE) {
warning("Jackknife variance estimation is not possible, due to the lack of it in the supplied model. Will be ignored.",
call. = FALSE)
jackknife.estimation <- FALSE
}
if (!any(names(object) == "variance.asymptotic") && asymptotic) {
warning("Asymptotic variance estimation is not possible, due to the lack of it in the supplied model. Will be ignored.",
call. = FALSE)
asymptotic <- FALSE
}
cl <- class(object)
if (any(names(object) == "variance.asymptotic") && asymptotic == FALSE) {
object <- object[setdiff(names(object), c("PSI", "c11", "a11",
"sigma", "sigma.gamma", "g", "s", "variance.asymptotic"))]
}
if (any(names(object) == "variance.jackknife") && jackknife.estimation ==
FALSE) {
object <- object[setdiff(names(object), c("extrapolation.variance",
"variance.jackknife", "variance.jackknife.lambda"))]
}
class(object) <- cl
estimates <- object$SIMEX.estimates[-1, -1]
lambda <- object$lambda
ncoef <- length(coef(object))
ndes <- dim(object$model$model)[1]
p.names <- names(coef(object))
SIMEX.estimate <- vector(mode = "numeric", length = ncoef)
switch(fitting.method, quad = extrapolation <- lm(estimates ~ lambda +
I(lambda^2)), line = extrapolation <- lm(estimates ~ lambda), logl = extrapolation <- lm(I(log(t(t(estimates) +
(abs(apply(estimates, 2, min)) + 1) * (apply(estimates, 2, min) <=
0)))) ~ lambda), log2 = extrapolation <- fit.logl(lambda, p.names,
estimates), nonl = extrapolation <- fit.nls(lambda, p.names, estimates))
if (any(class(extrapolation) == "lm") && fitting.method == "log2")
fitting.method <- "logl"
switch(fitting.method, quad = SIMEX.estimate <- predict(extrapolation,
newdata = data.frame(lambda = -1)), line = SIMEX.estimate <- predict(extrapolation,
newdata = data.frame(lambda = -1)), nonl = for (i in 1:length(p.names)) SIMEX.estimate[i] <- predict(extrapolation[[p.names[i]]],
newdata = data.frame(lambda = -1)), log2 = for (i in 1:length(p.names)) SIMEX.estimate[i] <- predict(extrapolation[[p.names[i]]],
newdata = data.frame(lambda = -1)) - ((abs(apply(estimates, 2,
min)) + 1) * (apply(estimates, 2, min) <= 0))[i], logl = SIMEX.estimate <- exp(predict(extrapolation,
newdata = data.frame(lambda = -1))) - (abs(apply(estimates, 2,
min)) + 1) * (apply(estimates, 2, min) <= 0))
if (jackknife.estimation != FALSE) {
variance.jackknife <- object$variance.jackknife.lambda[-1, -1]
switch(jackknife.estimation, quad = extrapolation.variance <- lm(variance.jackknife ~
lambda + I(lambda^2)), line = extrapolation.variance <- lm(variance.jackknife ~
lambda), logl = extrapolation.variance <- lm(I(log(t(t(variance.jackknife) +
(abs(apply(variance.jackknife, 2, min)) + 1) * (apply(variance.jackknife,
2, min) <= 0)))) ~ lambda), nonl = extrapolation.variance <- fit.nls(lambda,
1:NCOL(variance.jackknife), variance.jackknife))
variance.jackknife2 <- vector("numeric", ncoef^2)
switch(jackknife.estimation, nonl = for (i in 1:NCOL(variance.jackknife)) variance.jackknife2[i] <- predict(extrapolation.variance[[i]],
newdata = data.frame(lambda = -1)), quad = variance.jackknife2 <- predict(extrapolation.variance,
newdata = data.frame(lambda = -1)), line = variance.jackknife2 <- predict(extrapolation.variance,
newdata = data.frame(lambda = -1)), logl = variance.jackknife2 <- exp(predict(extrapolation.variance,
newdata = data.frame(lambda = -1))) - (abs(apply(variance.jackknife,
2, min)) + 1) * (apply(variance.jackknife, 2, min) <= 0))
variance.jackknife <- rbind(variance.jackknife2, variance.jackknife)
variance.jackknife.lambda <- cbind(c(-1, lambda), variance.jackknife)
variance.jackknife <- matrix(variance.jackknife[1, ], nrow = ncoef,
ncol = ncoef, byrow = TRUE)
dimnames(variance.jackknife) <- list(p.names, p.names)
object$variance.jackknife.lambda <- variance.jackknife.lambda
object$variance.jackknife <- variance.jackknife
object$extrapolation.variance <- extrapolation.variance
}
if (asymptotic) {
sigma <- object$sigma
s <- construct.s(ncoef, lambda, fitting.method, extrapolation)
d.inv <- solve(s %*% t(s))
sigma.gamma <- d.inv %*% s %*% sigma %*% t(s) %*% d.inv
g <- list()
switch(fitting.method, quad = g <- c(1, -1, 1), line = g <- c(1,
-1), logl = for (i in 1:ncoef) g[[i]] <- c(exp(coef(extrapolation)[1,
i] - coef(extrapolation)[2, i]), -exp(coef(extrapolation)[1,
i] - coef(extrapolation)[2, i])), log2 = for (i in 1:ncoef) g[[i]] <- c(exp(coef(extrapolation[[i]])[1] -
coef(extrapolation[[i]])[2]), -exp(coef(extrapolation[[i]])[1] -
coef(extrapolation[[i]])[2])), nonl = for (i in 1:ncoef) g[[i]] <- c(-1,
-(coef(extrapolation[[i]])[3] - 1)^-1, coef(extrapolation[[i]])[2]/(coef(extrapolation[[i]])[3] -
1)^2))
g <- diag.block(g, ncoef)
variance.asymptotic <- (t(g) %*% sigma.gamma %*% g)/ndes
dimnames(variance.asymptotic) <- list(p.names, p.names)
object$sigma.gamma <- sigma.gamma
object$g <- g
object$s <- s
object$variance.asymptotic <- variance.asymptotic
}
object$call$fitting.method <- fitting.method
object$call$jackknife.estimation <- jackknife.estimation
object$call$asymptotic <- asymptotic
object$SIMEX.estimates[1, ] <- c(-1, SIMEX.estimate)
object$coefficients <- as.vector(SIMEX.estimate)
names(object$coefficients) <- p.names
fitted.values <- predict(object, newdata = object$model$model[, -1,
drop = FALSE], type = "response")
object$fitted.values <- fitted.values
if (is.factor(object$model$model[, 1]))
object$residuals <- as.numeric(levels(object$model$model[, 1]))[object$model$model[,
1]] - fitted.values else object$model$model[, 1] - fitted.values
object$extrapolation <- extrapolation
return(object)
} |
chart.Correlation <-
function (R, histogram = TRUE, method=c("pearson", "kendall", "spearman"), pch=1, ...)
{
x = checkData(R, method="matrix")
if(missing(method)) method=method[1]
cormeth <- method
panel.cor <- function(x, y, digits=2, prefix="", use="pairwise.complete.obs", method=cormeth, cex.cor, ...)
{
usr <- par("usr"); on.exit(par(usr))
par(usr = c(0, 1, 0, 1))
r <- cor(x, y, use=use, method=method)
txt <- format(c(r, 0.123456789), digits=digits)[1]
txt <- paste(prefix, txt, sep="")
if(missing(cex.cor)) cex <- 0.8/strwidth(txt)
test <- cor.test(as.numeric(x),as.numeric(y), method=method)
Signif <- symnum(test$p.value, corr = FALSE, na = FALSE,
cutpoints = c(0, 0.001, 0.01, 0.05, 0.1, 1),
symbols = c("***", "**", "*", ".", " "))
text(0.5, 0.5, txt, cex = cex * (abs(r) + .3) / 1.3)
text(.8, .8, Signif, cex=cex, col=2)
}
f <- function(t) {
dnorm(t, mean=mean(x), sd=sd.xts(x) )
}
dotargs <- list(...)
dotargs$method <- NULL
rm(method)
hist.panel = function (x, ...=NULL ) {
par(new = TRUE)
hist(x,
col = "light gray",
probability = TRUE,
axes = FALSE,
main = "",
breaks = "FD")
lines(density(x, na.rm=TRUE),
col = "red",
lwd = 1)
rug(x)
}
if(histogram)
pairs(x, gap=0, lower.panel=panel.smooth, upper.panel=panel.cor, diag.panel=hist.panel, pch=pch, ...)
else
pairs(x, gap=0, lower.panel=panel.smooth, upper.panel=panel.cor, pch=pch, ...)
} |
expected <- eval(parse(text="structure(c(794, 150, 86, 570), .Dim = c(2L, 2L), .Dimnames = structure(list(`2nd Survey` = c(\"Approve\", \"Disapprove\"), `1st Survey` = c(\"Approve\", \"Disapprove\")), .Names = c(\"2nd Survey\", \"1st Survey\")))"));
test(id=0, code={
argv <- eval(parse(text="list(structure(c(794, 86, 150, 570), .Dim = c(2L, 2L), .Dimnames = structure(list(`1st Survey` = c(\"Approve\", \"Disapprove\"), `2nd Survey` = c(\"Approve\", \"Disapprove\")), .Names = c(\"1st Survey\", \"2nd Survey\"))))"));
.Internal(t.default(argv[[1]]));
}, o=expected); |
context("Karcher mean")
test_that("Karcher mean with zero-row gives correct output ", {
expect_that(karcher.mean.sphere(matrix(NA, nrow=0, ncol=2)), equals(c(phi=NA, lambda=NA)))
expect_that(karcher.mean.sphere(matrix(NA, nrow=0, ncol=2), var=TRUE), equals(list(mean=c(phi=NA, lambda=NA), var=c(phi=NA, lambda=NA))))
})
test_that("Karcher mean with one-row gives correct output ", {
x <- cbind(phi=1, lambda=0)
expect_that(karcher.mean.sphere(x), equals(c(phi=1, lambda=0)))
expect_that(karcher.mean.sphere(x, var=TRUE), equals(list(mean=c(phi=1, lambda=0), var=c(phi=NA, lambda=NA))))
})
test_that("Karcher mean with two-rows gives correct output ", {
x <- cbind(phi=c(0, 0), lambda=c(0, pi/2))
expect_that(karcher.mean.sphere(x), equals(c(phi=0, lambda=pi/4)))
expect_that(karcher.mean.sphere(x, var=TRUE), equals(list(mean=c(phi=0, lambda=pi/4), var=(pi/4)^2)))
}) |
format_bdvis <- function(indf, source=NULL, config=NULL, quiet=FALSE, gettaxo=F, ...) {
bd_check_df(indf)
if (!(is.null(source))) {
match.arg(source, sources_list)
if (!(quiet)) message(c("Mapping according to ", source, " format"))
new_fields <- bd_get_source(source)
} else if (!(is.null(config))) {
if (!(quiet)) message("Mapping according to config object")
new_fields <- bd_parse_config(config)
} else {
if (!(quiet)) message("Mapping via individual parameters")
new_fields <- bd_parse_args(list(...))
}
if (!(is.null(new_fields$Latitude)) && new_fields$Latitude != "Latitude") {
if (new_fields$Latitude %in% names(indf)) {
if ("Latitude" %in% names(indf)) {
names(indf)[names(indf)=="Latitude"] <- "Latitude::original"
if (!(quiet)) message("Changed \"Latitude\" to \"Latitude::original\"")
}
names(indf)[names(indf)==new_fields$Latitude] <- "Latitude"
if (!(quiet)) message(c("Changed \"",new_fields$Latitude,"\" to \"Latitude\""))
}
}
if (!(is.null(new_fields$Longitude)) && new_fields$Longitude != "Longitude") {
if (new_fields$Longitude %in% names(indf)) {
if ("Longitude" %in% names(indf)) {
names(indf)[names(indf)=="Longitude"] <- "Longitude::original"
if (!(quiet)) message("Changed \"Longitude\" to \"Longitude::original\"")
}
names(indf)[names(indf)==new_fields$Longitude] <- "Longitude"
if (!(quiet)) message(c("Changed \"",new_fields$Longitude,"\" to \"Longitude\""))
}
}
if (!(is.null(new_fields$Date_collected)) && new_fields$Date_collected != "Date_collected") {
if (new_fields$Date_collected %in% names(indf)) {
if ("Date_collected" %in% names(indf)) {
names(indf)[names(indf)=="Date_collected"] <- "Date_collected::original"
if (!(quiet)) message("Changed \"Date_collected\" to \"Date_collected::original\"")
}
names(indf)[names(indf)==new_fields$Date_collected] <- "Date_collected"
if (!(quiet)) message(c("Changed \"",new_fields$Date_collected,"\" to \"Date_collected\""))
}
}
if (!(is.null(new_fields$Scientific_name)) && new_fields$Scientific_name != "Scientific_name") {
if (new_fields$Scientific_name %in% names(indf)) {
if ("Scientific_name" %in% names(indf)) {
names(indf)[names(indf)=="Scientific_name"] <- "Scientific_name::original"
if (!(quiet)) message("Changed \"Scientific_name\" to \"Scientific_name::original\"")
}
names(indf)[names(indf)==new_fields$Scientific_name] <- "Scientific_name"
if (!(quiet)) message(c("Changed \"",new_fields$Scientific_name,"\" to \"Scientific_name\""))
}
}
indf$Latitude <- as.numeric(indf$Latitude)
indf$Longitude <- as.numeric(indf$Longitude)
indf <- getcellid(indf)
if(gettaxo){
indf <- gettaxo(indf)
}
indf
}
sources_list <- c(
"rgbif",
"rvertnet",
"rinat"
)
bd_get_source <- function(source) {
bd_sources <- list(
rgbif = list(
Latitude = "decimalLatitude",
Longitude = "decimalLongitude",
Date_collected = "eventDate",
Scientific_name = "name"
),
rvertnet = list(
Latitude = "decimallatitude",
Longitude = "decimallongitude",
Date_collected = "eventdate",
Scientific_name = "scientificname"
),
rinat = list(
Latitude = "latitude",
Longitude = "longitude",
Date_collected = "observed_on",
Scientific_name = "taxon.name"
)
)
return(bd_sources[[source]])
}
bd_parse_config <- function(config){
if (!("Latitude" %in% names(config))) stop("\"Latitude\" missing from configuration object")
if (!("Longitude" %in% names(config))) stop("\"Longitude\" missing from configuration object")
if (!("Date_collected" %in% names(config))) stop("\"Date_collected\" missing from configuration object")
if (!("Scientific_name" %in% names(config))) stop("\"Scientific_name\" missing from configuration object")
return(config)
}
bd_parse_args <- function(args) {
bd_args <- list()
if ("Latitude" %in% names(args)) {
bd_args$Latitude <- args$Latitude
} else {
bd_args$Latitude <- NULL
}
if ("Longitude" %in% names(args)) {
bd_args$Longitude <- args$Longitude
} else {
bd_args$Longitude <- NULL
}
if ("Date_collected" %in% names(args)) {
bd_args$Date_collected <- args$Date_collected
} else {
bd_args$Date_collected <- NULL
}
if ("Scientific_name" %in% names(args)) {
bd_args$Scientific_name <- args$Scientific_name
} else {
bd_args$Scientific_name <- NULL
}
return(bd_args)
}
bd_check_df <- function(indf) {
if(is.na(indf) || (is.data.frame(indf) && nrow(indf) == 0)) stop("Input data frame missing or empty")
if(!(is.data.frame(indf))) stop("Provided argument is not a data.frame")
return(invisible())
} |
`implementInteractions.fnc` <-
function(m) {
nams = strsplit(colnames(m), ":")
for (i in 1:length(nams)) {
if (length(nams[[i]]) > 1) {
m[,i] = m[,nams[[i]][1]]
for (j in 2:length(nams[[i]])) {
m[,i] = m[,i]*m[,nams[[i]][j]]
}
}
}
return(m)
} |
fslmean = function(img, nonzero = FALSE, verbose = TRUE, ts = FALSE){
opts = "-m"
opts = ifelse(nonzero, toupper(opts), opts)
val = fslstats(img, opts = opts, verbose = verbose, ts = ts)
val = strsplit(val, " ")
if (length(val) == 1) {
val = as.numeric(val[[1]])
} else {
val = sapply(val, as.numeric)
}
val
} |
WITSclean<-function(CSVfile,YEAR,threshold,cutoff){
DATAV1<-utils::read.csv(CSVfile)
DATA<-dplyr::filter(DATAV1,DATAV1$Year==YEAR)
Sender<-as.vector(DATA[,"PartnerISO3"])
Sender<- gsub('SER', 'SRB', Sender)
Sender<- gsub('TMP', 'TLS', Sender)
Sender<- gsub('ZAR', 'COD', Sender)
Sender<- gsub('ROM', 'ROU', Sender)
Sender<- gsub('SUD', 'SDN', Sender)
Sender<- gsub('MNT', 'MNE', Sender)
Receiver<-as.vector(DATA[,"ReporterISO3"])
Receiver<- gsub('SER', 'SRB', Receiver)
Receiver<- gsub('TMP', 'TLS', Receiver)
Receiver<- gsub('ZAR', 'COD', Receiver)
Receiver<- gsub('ROM', 'ROU', Receiver)
Receiver<- gsub('SUD', 'SDN', Receiver)
Receiver<- gsub('MNT', 'MNE', Receiver)
VAL<-DATA[,"TradeValue.in.1000.USD"]
FULLel<-data.frame(Sender=Sender,
Receiver=Receiver,
VAL=VAL,stringsAsFactors = FALSE)
WDIDataSeries<-WDI::WDI_data
WDICountryInfo<-WDIDataSeries$country
WD<-as.data.frame(WDICountryInfo,stringsAsFactors = FALSE)
COUNTRYlist<-WDICountryInfo[,"iso3c"]
REGIONlist<-WDICountryInfo[,"region"]
INCOMElist<-WDICountryInfo[,"income"]
CountryRegion<-cbind(COUNTRYlist,REGIONlist)
CountryIncome<-cbind(COUNTRYlist,INCOMElist)
AggReg<-c("All","EUN","UNS","OAS","FRE",
"SPE","VAT","UMI","ATA","PCN","AIA","COK",
"SHN","MSR","NIU",
"BES","BLM","BUN","BVT","CCK","CXR","FLK",
"HMD","IOT","NFK","SGS","TKL",
"ESH","SPM","ATF"
)
AggRegMat<-matrix("Aggregates",length(AggReg),2)
AggRegMat[,1]<-AggReg
CountryRegion<-rbind(CountryRegion,AggRegMat)
CountryIncome<-rbind(CountryIncome,AggRegMat)
CR<-as.data.frame(CountryRegion,stringsAsFactors = FALSE)
ALL_AGG<-dplyr::filter(CR,REGIONlist=="Aggregates")
ALL_AGG<-ALL_AGG$COUNTRYlist
ALL_AGG<-as.vector(ALL_AGG)
WDIgdp1<-WDI::WDI(country="all",indicator = "NY.GDP.PCAP.KD", start = YEAR, end=YEAR )
WDIgdp1<-as.data.frame(WDIgdp1,stringsAsFactors=FALSE)
WDIgdp1$iso3<-WD$iso3c[match(WDIgdp1$iso2c,WD$iso2c)]
WDIgdp2<-cbind(as.vector(WDIgdp1$iso3),
as.vector(WDIgdp1$NY.GDP.PCAP.KD))
colnames(WDIgdp2)<-c("iso3","GDP")
WDIgdp2<-as.data.frame(WDIgdp2,stringsAsFactors=FALSE)
WDIGDPgrowth1<-WDI::WDI(country="all",indicator = "NY.GDP.MKTP.KD.ZG", start = YEAR, end=YEAR )
WDIGDPgrowth1<-as.data.frame(WDIGDPgrowth1,stringsAsFactors=FALSE)
WDIGDPgrowth1$iso3<-WD$iso3c[match(WDIGDPgrowth1$iso2c,WD$iso2c)]
WDIGDPgrowth2<-cbind(as.vector(WDIGDPgrowth1$iso3),
as.vector(WDIGDPgrowth1$NY.GDP.MKTP.KD.ZG))
colnames(WDIGDPgrowth2)<-c("iso3","GDPgrowth")
WDIGDPgrowth2<-as.data.frame(WDIGDPgrowth2,stringsAsFactors=FALSE)
WDIGDPPC1<-WDI::WDI(country="all",indicator = "NY.GDP.PCAP.PP.KD", start = YEAR, end=YEAR )
WDIGDPPC1<-as.data.frame(WDIGDPPC1,stringsAsFactors=FALSE)
WDIGDPPC1$iso3<-WD$iso3c[match(WDIGDPPC1$iso2c,WD$iso2c)]
WDIGDPPC2<-cbind(as.vector(WDIGDPPC1$iso3),as.vector(WDIGDPPC1$NY.GDP.PCAP.PP.KD))
colnames(WDIGDPPC2)<-c("iso3","GDPPC")
WDIGDPPC2<-as.data.frame(WDIGDPPC2,stringsAsFactors=FALSE)
WDIFDI1<-WDI::WDI(country="all",indicator = "BN.KLT.DINV.CD", start = YEAR, end=YEAR )
WDIFDI1<-as.data.frame(WDIFDI1,stringsAsFactors=FALSE)
WDIFDI1$iso3<-WD$iso3c[match(WDIFDI1$iso2c,WD$iso2c)]
WDIFDI2<-cbind(as.vector(WDIFDI1$iso3),as.vector(WDIFDI1$BN.KLT.DINV.CD))
colnames(WDIFDI2)<-c("iso3","FDI")
WDIFDI2<-as.data.frame(WDIFDI2,stringsAsFactors=FALSE)
TotalCountryExports<-subset(FULLel,Receiver %in% "All")
AllAllTotal<-as.matrix(subset(TotalCountryExports,Sender %in% "All"))
GrandTotal<-as.numeric(AllAllTotal[,3])
Share<-list()
for (i in 1:length(VAL)){
Share[[i]]<-(VAL[i]/GrandTotal)*100
}
Share <-plyr::ldply(Share, data.frame)
colnames(Share)<-"Share"
FULLel<-cbind(FULLel,Share)
G1<-igraph::graph_from_data_frame(FULLel,direct=TRUE)
igraph::E(G1)$weight<-FULLel[,4]
igraph::V(G1)$id<-igraph::V(G1)$name
CountryNames<-igraph::V(G1)$name
NotCovered<-subset(CountryNames,!(CountryNames %in% CountryRegion[,1]))
NotCoveredWDI<-subset(CountryNames,!(CountryNames %in% WDIgdp2$iso3))
mm<-matrix("NA",length(NotCovered),2)
mm[,1]<-NotCovered
CountryRegion2<-rbind(CountryRegion,mm)
CountryIncome2<-rbind(CountryIncome,mm)
mm2<-matrix("NA",length(NotCoveredWDI),2)
mm2[,1]<-NotCoveredWDI
colnames(mm2)<-colnames(WDIgdp2)
WDIgdp3<-rbind(WDIgdp2,mm2)
colnames(mm2)<-colnames(WDIGDPPC2)
WDIGDPPC3<-rbind(WDIGDPPC2,mm2)
colnames(mm2)<-colnames(WDIGDPgrowth2)
WDIGDPgrowth3<-rbind(WDIGDPgrowth2,mm2)
colnames(mm2)<-colnames(WDIFDI2)
WDIFDI3<-rbind(WDIFDI2,mm2)
RegionListAttr<-list()
IncomeListAttr<-list()
GDPListattr<-list()
GDPPCListattr<-list()
GDPgrowthListAttr<-list()
FDIListAttr<-list()
for (i in 1:length(CountryNames)){
RegionListAttr[[i]]<-subset(CountryRegion2,COUNTRYlist %in% CountryNames[i])
IncomeListAttr[[i]]<-subset(CountryIncome2,COUNTRYlist %in% CountryNames[i])
GDPListattr[[i]]<-subset(WDIgdp3,WDIgdp3$iso3 %in% CountryNames[i])
GDPPCListattr[[i]]<-subset(WDIGDPPC3,WDIGDPgrowth3$iso3 %in% CountryNames[i])
GDPgrowthListAttr[[i]]<-subset(WDIGDPgrowth3,WDIGDPgrowth3$iso3 %in% CountryNames[i])
FDIListAttr[[i]]<-subset(WDIFDI3,WDIFDI3$iso3 %in% CountryNames[i])
}
dfREG<-plyr::ldply(RegionListAttr, data.frame)
dfINC<-plyr::ldply(IncomeListAttr,data.frame)
dfGDP<-plyr::ldply(GDPListattr,data.frame)
dfGDPPC<-plyr::ldply(GDPPCListattr, data.frame)
dfGDPgrowth<-plyr::ldply(GDPgrowthListAttr, data.frame)
dfFDI<-plyr::ldply(FDIListAttr, data.frame)
target<-CountryNames
dfREG<-dfREG[match(target,dfREG$COUNTRYlist),]
RR<-as.vector(dfREG[,2])
RR1<-c(RR)
RR1<-unlist(RR1)
RR2<-as.factor(RR1)
H<-as.character(dfREG$REGIONlist)
dfINC<-dfINC[match(target,dfINC$COUNTRYlist),]
KK<-as.vector(dfINC[,2])
KK1<-c(KK)
KK1<-unlist(KK1)
KK2<-as.factor(KK1)
U<-as.character(dfINC$INCOMElist)
A<-levels(RR2)
B<-1:length(A)
KEY<-cbind(A,B)
Ainc<-levels(KK2)
Binc<-1:length(Ainc)
dfGDP<-dfGDP[match(target,dfGDP$iso3),]
dfGDPPC<-dfGDPPC[match(target,dfGDPPC$iso3),]
dfGDPgrowth<-dfGDPgrowth[match(target,dfGDPgrowth$iso3),]
dfFDI<-dfFDI[match(target,dfFDI$iso3),]
GGDP<-as.vector(dfGDP[,2])
GGDP<-suppressWarnings(as.numeric(GGDP))
GGDPPC<-as.vector(dfGDPPC[,2])
GGDPPC<-suppressWarnings(as.numeric(GGDPPC))
GGDPgrowth<-as.vector(dfGDPgrowth[,2])
GFDI<-as.vector(dfFDI[,2])
IH<-fastmatch::fmatch(KK,Ainc)
CH<-fastmatch::fmatch(RR, A)
igraph::V(G1)$regionNAME<-H
igraph::V(G1)$region<-CH
igraph::V(G1)$income<-IH
igraph::V(G1)$GDP<-GGDP
igraph::V(G1)$GDPPC<-GGDPPC
igraph::V(G1)$logGDP<-log(GGDP)
igraph::V(G1)$logGDPPC<-log(GGDPPC)
igraph::V(G1)$GDPgrowth<-GGDPgrowth
igraph::V(G1)$FDI<-GFDI
DEL_LIST<-subset(igraph::V(G1)$name,
igraph::V(G1)$name %in% ALL_AGG)
G1<-igraph::delete_vertices(G1,c(DEL_LIST,"All"))
G3<-igraph::delete.vertices(G1, which(is.na(igraph::V(G1)$region)))
BACK_BONE_PREP<-igraph::get.data.frame(G3,what="vertices")
if(threshold==TRUE){
G4<-igraph::delete.edges(G3,which(igraph::E(G3)$weight<cutoff))
} else {
G4<-get.backbone(G3,cutoff,TRUE)
BB_ID<-igraph::get.data.frame(G4,what="vertices")
BB_ATTR<-merge(BB_ID,BACK_BONE_PREP,by.all="name",all.x=TRUE,
all.y=FALSE)
BB_ATTR<-BB_ATTR[order(match(BB_ATTR[, "name"],igraph::V(G4)$name)),]
igraph::V(G4)$region<-BB_ATTR$region
igraph::V(G4)$regionNAME<-BB_ATTR$regionNAME
igraph::V(G4)$income<-BB_ATTR$income
igraph::V(G4)$GDP<-BB_ATTR$GDP
igraph::V(G4)$GDPPC<-BB_ATTR$GDPPC
igraph::V(G4)$logGDP<-BB_ATTR$logGDP
igraph::V(G4)$logGDPPC<-BB_ATTR$logGDPPC
igraph::V(G4)$GDPgrowth<-BB_ATTR$GDPgrowth
igraph::V(G4)$FDI<-BB_ATTR$FDI
igraph::V(G4)$id<-BB_ATTR$id
}
G5<-igraph::delete.vertices(G4, which(igraph::degree(G4)==0))
EW<-igraph::E(G5)$weight
EW2<-as.numeric(EW)
G6<-igraph::delete_edge_attr(G5,"weight")
igraph::E(G6)$weight<-EW2
return(G6)
} |
if (getRversion() < 3.6) {
hcl.colors <- function (n, ...) {
if (n == 4) {
return(c("
} else {
colorRampPalette(c("
"
}
}
}
data("Seatbelts")
head(Seatbelts)
library("Ternary")
seat <- c("drivers", "front", "rear")
TernaryPlot(alab = seat[1], blab = seat[2], clab = seat[3])
TernaryPoints(Seatbelts[, seat])
par(mar = c(0, 0, 0, 0))
plot(0:20, rep(2, 21), pch = 0:20,
cex = 2, ylim = c(-1, 3), ann = FALSE)
text(0:20, rep(0, 21), 0:20)
beltLawPch <- ifelse(Seatbelts[, 'law'], 3, 1)
par(mar = c(0, 0, 0, 0))
TernaryPlot(alab = seat[1], blab = seat[2], clab = seat[3])
legend('topleft', c('Belt law', 'No law'), pch = c(3, 1))
TernaryPoints(Seatbelts[, seat], pch = beltLawPch)
nPoints <- nrow(Seatbelts)
rowCol <- hcl.colors(nPoints, palette = "viridis", alpha = 0.8)
SpectrumLegend <- function (spectrum, labels) {
nCol <- length(spectrum)
xMax <- TernaryXRange()[2]
yMax <- TernaryYRange()[2]
legendY0 <- yMax * 0.75
legendY1 <- yMax * 0.95
legendHeight <- legendY1 - legendY0
segX <- rep(xMax, nCol)
segY <- seq_len(nCol) / nCol
segY <- legendY0 + (segY * legendHeight)
segments(segX, segY - segY[1] + legendY0, y1 = segY, col = spectrum,
lwd = 4)
text(segX, c(legendY0, legendY1), labels, pos = 2)
}
par(mar = c(0, 0, 0, 0))
TernaryPlot(alab = seat[1], blab = seat[2], clab = seat[3])
legend('topleft', c('Belt law', 'No law'), pch = c(3, 1))
SpectrumLegend(rowCol, labels = c('Jan 1969', 'Dec 1984'))
TernaryPoints(Seatbelts[, seat], pch = beltLawPch,
lwd = 2,
col = rowCol)
fourSeasons <- hcl.colors(4, 'Spectral')
monthCol <- colorRampPalette(fourSeasons[c(1:4, 1)])(13)[c(7:12, 1:6)]
par(mar = c(0, 0, 0, 0))
TernaryPlot(alab = seat[1], blab = seat[2], clab = seat[3])
legend('topleft', c('Belt law', 'No law'), pch = c(3, 1))
SpectrumLegend(monthCol, c('Jan', 'Dec'))
TernaryPoints(Seatbelts[, seat], pch = beltLawPch,
lwd = 2,
col = monthCol)
par(mar = c(0, 0, 0, 0))
TernaryPlot(alab = seat[1], blab = seat[2], clab = seat[3],
xlim = c(0.055, 0.095), ylim = c(0.48, 0.52))
legend('topleft', c('No law', 'Belt law'),
col = 2:3, pch = 1, lwd = 2, lty = NA)
sizes <- c(3, 7, 12)
scale <- 200
legend('topright', title = 'Casualties / Mm', legend = sizes,
pt.cex = sizes / 1000 * scale,
pch = 1, lwd = 2, lty = NA)
TernaryPoints(Seatbelts[, seat], pch = 1, lwd = 2,
cex = Seatbelts[, 'DriversKilled'] / Seatbelts[, 'kms'] * scale,
col = 2 + Seatbelts[, 'law'])
oct <- month.name == 'October'
octBelts <- Seatbelts[oct, ]
par(mar = c(0, 0, 0, 0))
TernaryPlot(alab = seat[1], blab = seat[2], clab = seat[3],
xlim = c(0.055, 0.095), ylim = c(0.48, 0.52),
padding = 0.04)
TernarySegments(octBelts[-nrow(octBelts), seat], octBelts[-1, seat],
col = rowCol, lwd = 2)
TernaryText(octBelts[, seat], paste0("'", 69:84),
font = 2, cex = 1.5,
col = adjustcolor(rowCol[oct], alpha.f = 0.8)) |
plot.importance <- function(x, ..., top = 10, radar = TRUE, text_start_point = 0.5, text_size=3.5,
xmeasure = "sumCover", ymeasure = "sumGain"){
Feature <- sumGain <- sumCover <- meanGain <- meanCover <-
mean5Gain <- . <- value <- variable <- hjust <- NULL
if (is.null(top))
top <- nrow(x)
if (radar == FALSE) {
ggplot(data.frame(x[1:top, ]),
aes_string(x = xmeasure, y = ymeasure, label = "Feature")) +
geom_point() +
scale_size() + geom_label_repel() + theme_drwhy()
}else{
import <- as.data.table(x[1:top, ])
import <- import[1:top, .(Feature,
sumGain = sumGain / max(import[, sumGain]),
sumCover = sumCover / max(import[, sumCover]),
meanGain = meanGain / max(import[, meanGain]),
meanCover = meanCover / max(import[, meanCover]),
mean5Gain = mean5Gain / max(import[, mean5Gain]),
frequency = frequency / max(import[, frequency]))]
data<-import[,Feature:= ifelse(nchar(import[,Feature])>20, gsub(":", ": :",import[,Feature]),Feature)]
import$Feature <- factor(import$Feature, levels = import$Feature[order(import$sumGain, decreasing = TRUE)])
numberOfBars=nrow(import)
angle= 90-360*(row(import)[,1]-0.5)/numberOfBars
import$hjust<-ifelse( angle < -90, 1, 0)
import$angle<-ifelse(angle < -90, angle+180, angle)
data_to_plot <- melt(import, id = c(1,8,9), measures = 2:6, value.factor = FALSE)
data<-data_to_plot[,.(hjust=mean(hjust),angle=mean(angle)), by=Feature]
ggplot(data.frame(data_to_plot),
aes(x = Feature, y = value, colour = variable, group = variable)) +
geom_line(size = 1.5) +
geom_point(size = 2.5) +
theme_drwhy() +
theme(axis.title.x = element_blank(),
axis.title.y = element_blank(),
legend.position = "bottom",
panel.grid.major.y = element_line(colour = "gray68", linetype = "dashed", size = 0.4),
axis.line = element_blank(),
axis.text.x=element_blank(),) +
labs(fill = "Measures")+
coord_radar() +
geom_text(data=data, aes(x=Feature, y= rep(text_start_point,top), label=lapply(strwrap(data[,Feature], width = 10, simplify = FALSE), paste, collapse="\n"), hjust=hjust), color="
}
} |
get_dummies. <- function(.df,
cols = c(where(is.character), where(is.factor)),
prefix = TRUE,
prefix_sep = "_",
drop_first = FALSE,
dummify_na = TRUE) {
UseMethod("get_dummies.")
}
get_dummies..tidytable <- function(.df,
cols = c(where(is.character), where(is.factor)),
prefix = TRUE,
prefix_sep = "_",
drop_first = FALSE,
dummify_na = TRUE) {
.df <- shallow(.df)
vec_assert(prefix, logical(), 1)
vec_assert(prefix_sep, character(), 1)
vec_assert(drop_first, logical(), 1)
vec_assert(dummify_na, logical(), 1)
cols <- tidyselect_syms(.df, {{ cols }})
original_cols <- copy(names(.df))
ordered_cols <- character()
for (col in cols) {
col_name <- as.character(col)
if (drop_first) {
unique_vals <- vec_unique(as.character(.df[[col_name]]))[-1]
} else {
unique_vals <- vec_unique(as.character(.df[[col_name]]))
}
if (dummify_na) {
unique_vals <- unique_vals %|% "NA"
} else {
unique_vals <- unique_vals[!is.na(unique_vals)]
}
if (prefix) {
new_names <- paste(col_name, unique_vals, sep = prefix_sep)
} else {
new_names <- unique_vals
}
not_na_cols <- new_names[unique_vals != "NA"]
unique_vals <- unique_vals[unique_vals != "NA"]
dummy_calls <- vector("list", length(unique_vals))
names(dummy_calls) <- not_na_cols
for (i in seq_along(unique_vals)) {
dummy_calls[[i]] <- expr(ifelse.(!!col == !!unique_vals[i], 1L, 0L, 0L))
}
.df <- mutate.(.df, !!!dummy_calls)
if (dummify_na) {
na_col <- new_names[new_names %notin% not_na_cols]
if (length(na_col) > 0) {
.df <- mutate.(.df, !!na_col := as.integer(is.na(!!col)))
}
}
new_names <- f_sort(new_names)
ordered_cols <- c(ordered_cols, new_names)
}
final_order <- c(original_cols, ordered_cols)
setcolorder(.df, final_order)
.df
}
get_dummies..data.frame <- function(.df,
cols = c(where(is.character), where(is.factor)),
prefix = TRUE,
prefix_sep = "_",
drop_first = FALSE,
dummify_na = TRUE) {
.df <- as_tidytable(.df)
get_dummies.(.df, {{ cols }}, prefix, prefix_sep, drop_first, dummify_na)
}
globalVariables("where") |
surv_br23 <- function(x){
covariates <- c('BRBI','BRSEF','BRSEE','BRFU','BRST','BRBS','BRAS','BRHL')
arm1_qol <- brc_qol(x[x$arm==1,])
arm2_qol <- brc_qol(x[x$arm==2,])
univ_formulas <- sapply(covariates,function(y) as.formula(paste('Surv(time, event)~', y)))
univ_arm1 <- lapply(univ_formulas,function(y){coxph(y, data = arm1_qol)})
univ_arm2 <- lapply(univ_formulas,function(y){coxph(y, data = arm2_qol)})
univ_results <- mapply(function(x1,x2){
x1 <- summary(x1)
x2 <- summary(x2)
HR <- signif(x2$coef[2]/x1$coef[2], digits=3);
HR.confint.lower <- signif(x2$conf.int[,"lower .95"]/x1$conf.int[,"lower .95"], 3)
HR.confint.upper <- signif(x2$conf.int[,"upper .95"]/x1$conf.int[,"upper .95"],3)
res<-c(HR,HR.confint.lower,HR.confint.upper)
names(res) <- c('HR','Lower 95% CI','Upper 95% CI')
return(res)},
univ_arm1,univ_arm2)
relative.HR <- t(as.data.frame(univ_results, check.names = FALSE))
return(relative.HR)
}
utils::globalVariables(c("as.data.frame","as.formula")) |
rblnd <- function(obswin, bufferdist, lambda, meanlog, sdlog, seed = NULL){
wsim <- Frame(dilation(obswin, bufferdist))
if (!missing(seed)){set.seed(seed)}
pp <- rpoispp(lambda, win = wsim, nsim = 1, drop = TRUE)
if (!missing(seed)){set.seed(seed)}
radius <- rlnorm(pp$n, meanlog = meanlog, sdlog = sdlog)
pointlocations <- cbind(X = pp$x, Y = pp$y)
pointlocations <- split(cbind(pointlocations), row(pointlocations))
grains <- mapply(disc, radius = radius, centre = pointlocations, SIMPLIFY = FALSE)
xisim <- union.owin(as.solist(grains))
xi <- intersect.owin(xisim, obswin)
return(xi)
} |
BIFIE.BIFIEcdata2BIFIEdata <- function( bifieobj, varnames=NULL, impdata.index=NULL )
{
if ( ! bifieobj$cdata ){
stop( "You may want to use 'BIFIE.BIFIEdata2BIFIEcdata'\n")
}
bifieobj <- BIFIE.cdata.select( bifieobj=bifieobj, varnames=varnames,
impdata.index=impdata.index )
bifieobj$datalistM <- bifiesurvey_rcpp_bifiecdata2bifiedata(
datalistM_ind=as.matrix(bifieobj$datalistM_ind),
datalistM_imputed=as.matrix(bifieobj$datalistM_imputed),
Nimp=bifieobj$Nimp, dat1=as.matrix(bifieobj$dat1),
datalistM_impindex=as.matrix(bifieobj$datalistM_impindex) )$datalistM
bifieobj$cdata <- FALSE
bifieobj$datalistM_imputed <- NULL
bifieobj$datalistM_impindex <- NULL
bifieobj$datalistM_ind <- NULL
bifieobj$wgtrep <- as.matrix(bifieobj$wgtrep)
return(bifieobj)
} |
ggEdges <- function(ggObj, states) {
active <- states$active
activeNode <- states$nodes[active]
activeX <- states$x[active]
activeY <- states$y[active]
isActiveEdge <- states$activeEdge
lapply(seq_len(length(activeNode)),
function(i) {
nodeFrom <- activeNode[i]
nodeFrom_EdgeId <- which(states$from[isActiveEdge] == nodeFrom)
if (length(nodeFrom_EdgeId) != 0) {
nodeTo <- states$to[isActiveEdge][nodeFrom_EdgeId]
nodeTo_CoordId <- which(activeNode %in% nodeTo)
numNodesTo <- length(nodeTo_CoordId)
x <- c(rep(activeX[i], numNodesTo), activeX[nodeTo_CoordId])
y <- c(rep(activeY[i], numNodesTo), activeY[nodeTo_CoordId])
id <- rep(nodeTo_CoordId, 2)
ggObj <<- ggObj +
ggplot2::geom_path(
data = data.frame(
x = x,
y = y,
id = id
),
mapping = ggplot2::aes(x = x, y = y, group = id, colour = as.factor(id)),
colour = rep(states$colorEdge[isActiveEdge][nodeFrom_EdgeId][nodeTo %in% activeNode], 2),
inherit.aes = FALSE
)
}
NULL
}
)
return(ggObj)
}
ggLabels <- function(ggObj, states) {
active <- states$active
activeNode <- states$nodes[active]
activeX <- states$x[active]
activeY <- states$y[active]
activeAngle <- states$orbitAngle[active]
orbitDistance <- states$orbitDistance
lapply(seq_len(length(activeNode)),
function(i) {
if(states$showOrbit) {
x <- activeX[i] + mm2native(orbitDistance) * cos(activeAngle[i])
y <- activeY[i] + mm2native(orbitDistance) * sin(activeAngle[i])
label <- activeNode[i]
ggObj <<- ggObj +
ggplot2::geom_text(
data = data.frame(
x = x,
y = y,
label = label
),
mapping = ggplot2::aes(x = x, y = y, label = label),
colour= loon::l_getOption("foreground"),
inherit.aes = FALSE
)
}
NULL
}
)
return(ggObj)
}
ggNodes <- function(ggObj, states) {
active <- states$active
pch <- glyph_to_pch(states$glyph[active])
colour <- get_display_color(states$color[active],
states$selected[active])
fill <- rep(NA, length(colour))
fill[pch %in% 21:24] <- colour[pch %in% 21:24]
colour[pch %in% 21:24] <- loon::l_getOption("foreground")
x <- states$x[active]
y <- states$y[active]
ggObj <- ggObj +
ggplot2::geom_point(
data = data.frame(x = x, y = y),
mapping = ggplot2::aes(x = x, y = y),
shape = pch,
colour = colour,
fill = fill,
size = as_ggplot_size(states$size[active]),
inherit.aes = FALSE
)
return(ggObj)
}
ggNavPaths <- function(ggObj, states, nav_ids, widget) {
x <- states$x
y <- states$y
node <- states$nodes
fromLineSize <- 3
toLineSize <- 1
lapply(nav_ids,
function(nav_id) {
navigator <- loon::l_create_handle(c(widget, nav_id))
color <- as_hex6color(navigator['color'])
from <- navigator['from']
to <- navigator['to']
prop <- navigator['proportion']
if(length(from) != 0 && length(to) != 0) {
fromId <- sapply(1:length(from), function(i){which(node %in% from[i] == TRUE)})
toId <- sapply(1:length(to), function(i){which(node %in% to[i] == TRUE)})
if(length(to) >= 2) {
lapply(1:(length(to) - 1),
function(i){
ggObj <<- ggObj +
ggplot2::geom_path(
data = data.frame(
x = c(x[toId[i]], x[toId[i+1]]),
y = c(y[toId[i]], y[toId[i+1]])
),
mapping = ggplot2::aes(x = x, y = y),
colour = color,
size = toLineSize,
inherit.aes = FALSE
)
}
)
}
if(length(from) >= 2) {
lapply(1:(length(from) - 1),
function(i) {
ggObj <<- ggObj +
ggplot2::geom_path(
data = data.frame(
x = c(x[fromId[i]], x[fromId[i+1]]),
y = c(y[fromId[i]], y[fromId[i+1]])
),
mapping = ggplot2::aes(x = x, y = y),
colour = color,
size = fromLineSize,
inherit.aes = FALSE
)
}
)
}
xn <- (1 - prop) * x[fromId[length(fromId)]] + prop * x[toId[1]]
yn <- (1 - prop) * y[fromId[length(fromId)]] + prop * y[toId[1]]
ggObj <<- ggObj +
ggplot2::geom_path(
data = data.frame(
x = c(x[fromId[length(fromId)]], xn),
y = c(y[fromId[length(fromId)]], yn)
),
mapping = ggplot2::aes(x = x, y = y),
colour = color,
size = fromLineSize,
inherit.aes = FALSE
) +
ggplot2::geom_path(
data = data.frame(
x = c(xn, x[toId[1]]),
y = c(yn, y[toId[1]])
),
mapping = ggplot2::aes(x = x, y = y),
colour = color,
size = toLineSize,
inherit.aes = FALSE
)
}
NULL
}
)
return(ggObj)
}
ggNavPoints <- function(ggObj, states, nav_ids, widget) {
activeNavigator <- widget["activeNavigator"]
x <- states$x
y <- states$y
node <- states$nodes
sel_color <- as.character(loon::l_getOption("select-color"))
if (grepl("^
sel_color <- loon::hex12tohex6(sel_color)
}
navPointsSize <- 12
navTextSize <- 3
navDotsSize <- 2
stroke <- 2
lapply(nav_ids,
function(nav_id) {
navigator <- loon::l_create_handle(c(widget, nav_id))
color <- as_hex6color(navigator['color'])
from <- navigator['from']
to <- navigator['to']
prop <- navigator['proportion']
label <- navigator['label']
if(length(activeNavigator) != 0) {
if(activeNavigator == navigator) {
boundColor <- sel_color
} else {
boundColor <- loon::l_getOption("foreground")
stroke <- 1
}
} else {
boundColor <- loon::l_getOption("foreground")
stroke <- 1
}
fromId <- sapply(1:length(from), function(i){which(node %in% from[i] == TRUE)})
toId <- sapply(1:length(to), function(i){which(node %in% to[i] == TRUE)})
if(length(from) == 0) {
ggObj <<- ggObj +
ggplot2::geom_point(
data = data.frame(x = 0.1, y = 0.9),
mapping = ggplot2::aes(x = x, y = y),
size = navPointsSize,
fill = color,
colour = boundColor,
stroke = stroke,
shape = 21,
inherit.aes = FALSE
) +
ggplot2::geom_text(
data = data.frame(x = 0.1, y = 0.9, label = paste(label, collapse = " ")),
mapping = ggplot2::aes(x = x, y = y, label = label),
colour = loon::l_getOption("foreground"),
size = navTextSize,
inherit.aes = FALSE
)
} else if(length(from) == 1 & length(to) == 0) {
ggObj <<- ggObj +
ggplot2::geom_point(
data = data.frame(x = x[fromId], y = y[fromId]),
mapping = ggplot2::aes(x = x, y = y),
size = navPointsSize,
fill = color,
colour = boundColor,
stroke = stroke,
shape = 21,
inherit.aes = FALSE
) +
ggplot2::geom_text(
data = data.frame(x = x[fromId], y = y[fromId],
label = paste(label, collapse = " ")),
mapping = ggplot2::aes(x = x, y = y, label = label),
colour = loon::l_getOption("foreground"),
size = navTextSize,
inherit.aes = FALSE
)
} else {
xx <- (1 - prop) * x[fromId[length(fromId)]] + prop * x[toId[1]]
yy <- (1 - prop) * y[fromId[length(fromId)]] + prop * y[toId[1]]
ggObj <<- ggObj +
ggplot2::geom_point(
data = data.frame(
x = x[toId[length(toId)]],
y = y[toId[length(toId)]]
),
mapping = ggplot2::aes(x = x, y = y),
size = navDotsSize,
fill = color,
colour = loon::l_getOption("foreground"),
inherit.aes = FALSE,
shape = 21,
) +
ggplot2::geom_point(
data = data.frame(x = xx, y = yy),
mapping = ggplot2::aes(x = x, y = y),
size = navPointsSize,
fill = color,
colour = boundColor,
stroke = stroke,
shape = 21,
inherit.aes = FALSE
) +
ggplot2::geom_text(
data = data.frame(x = x[fromId], y = y[fromId],
label = paste(label, collapse = " ")),
mapping = ggplot2::aes(x = x, y = y, label = label),
colour = loon::l_getOption("foreground"),
size = navTextSize,
inherit.aes = FALSE
)
}
NULL
}
)
return(ggObj)
}
mm2native <- function(x) x/50 |
knitr::opts_chunk$set(
collapse = TRUE,
eval = nzchar(Sys.getenv("COMPILE_VIG")),
comment = "
)
library(tongfen)
library(dplyr)
library(ggplot2)
library(tidyr)
library(cancensus)
vsb_regions <- list(CSD=c("5915022","5915803"),
CT=c("9330069.01","9330069.02","9330069.00"))
geo_identifiers <- c()
years <- seq(2001,2016,5)
geo_identifiers <- paste0("GeoUIDCA",substr(as.character(years),3,4))
data <- years %>%
lapply(function(year){
dataset <- paste0("CA",substr(as.character(year),3,4))
uid_label <- paste0("GeoUID",dataset)
get_census(dataset, regions=vsb_regions, geo_format = 'sf', level="CT", quiet=TRUE) %>%
sf::st_sf() %>%
rename(!!as.name(uid_label):=GeoUID) %>%
mutate(Year=year)
}) %>% setNames(years)
data %>%
bind_rows() %>%
ggplot() +
geom_sf(fill="steelblue",colour="brown") +
coord_sf(datum=NA) +
facet_wrap("Year") +
labs(title="Vancouver census tracts",caption="StatCan Census 2001-2016")
correspondence <- estimate_tongfen_correspondence(data, geo_identifiers,
tolerance=200, computation_crs=3347)
head(correspondence)
tongfen_area_check <- check_tongfen_areas(data,correspondence)
tongfen_area_check %>%
filter(max_log_ratio>0.1)
mismatched_tongfen_ids <- tongfen_area_check %>%
filter(max_log_ratio>0.1) %>%
pull(TongfenID)
mismatch_correspondence <- correspondence %>%
filter(TongfenID %in% mismatched_tongfen_ids)
c(2001,2016) %>%
lapply(function(year){
tongfen_aggregate(data,mismatch_correspondence,base_geo = year) %>%
mutate(Year=year)
}) %>%
bind_rows() %>%
ggplot() +
geom_sf(data=sf::st_union(data[[4]])) +
geom_sf(fill="steelblue",colour="brown") +
coord_sf(datum=NA) +
facet_wrap("Year") +
labs(title="Tongfen area mismatch check",caption="StatCan Census 2001-2016")
years %>%
lapply(function(year){
tongfen_aggregate(data,correspondence,base_geo = year) %>%
mutate(Year=year)
}) %>%
bind_rows() %>%
ggplot() +
geom_sf(fill="steelblue",colour="brown") +
coord_sf(datum=NA) +
facet_wrap("Year") +
labs(title="Tongfen aggregates visual inspection",caption="StatCan Census 2001-2016")
meta <- meta_for_additive_variables(years,"Population")
meta
breaks = c(-0.15,-0.1,-0.075,-0.05,-0.025,0,0.025,0.05,0.1,0.2,0.3)
labels = c("-15% to -10%","-10% to -7.5%","-7.5% to -5%","-5% to -2.5%","-2.5% to 0%","0% to 2.5%","2.5% to 5%","5% to 10%","10% to 20%","20% to 30%")
colors <- RColorBrewer::brewer.pal(10,"PiYG")
compute_population_change_metrics <- function(data) {
geometric_average <- function(x,n){sign(x) * (exp(log(1+abs(x))/n)-1)}
data %>%
mutate(`2001 - 2006`=geometric_average((`Population_2006`-`Population_2001`)/`Population_2001`,5),
`2006 - 2011`=geometric_average((`Population_2011`-`Population_2006`)/`Population_2006`,5),
`2011 - 2016`=geometric_average((`Population_2016`-`Population_2011`)/`Population_2011`,5),
`2001 - 2016`=geometric_average((`Population_2016`-`Population_2001`)/`Population_2001`,15)) %>%
gather(key="Period",value="Population Change",c("2001 - 2006","2006 - 2011","2011 - 2016","2001 - 2016")) %>%
mutate(Period=factor(Period,levels=c("2001 - 2006","2006 - 2011","2011 - 2016","2001 - 2016"))) %>%
mutate(c=cut(`Population Change`,breaks=breaks, labels=labels))
}
plot_data <- tongfen_aggregate(data,correspondence,meta=meta,base_geo = "2001") %>%
compute_population_change_metrics()
ggplot(plot_data,aes(fill=c)) +
geom_sf(size=0.1) +
scale_fill_manual(values=setNames(colors,labels)) +
facet_wrap("Period",ncol=2) +
coord_sf(datum=NA) +
labs(fill="Average Annual\nPopulation Change",
title="Vancouver population change",
caption = "StatCan Census 2001-2016") |
wages_monotonic <- wages %>%
features(ln_wages, feat_monotonic)
test_that("feat_monotonic returns the right names", {
expect_equal(names(wages_monotonic),
c("id",
"increase",
"decrease",
"unvary",
"monotonic"))
})
test_that("feat_monotonic returns the right dimensions", {
expect_equal(dim(wages_monotonic),
c(888, 5))
})
library(dplyr)
test_that("feat_monotonic returns all ids", {
expect_equal(n_distinct(wages_monotonic$id), 888)
}) |
Lsys <- function(init = NULL, rules = NULL, n = 5,
retAll = TRUE, verbose = 1L) {
nc <- nchar(rules$inp)
if (any(nc > 1)) stop("Input variables must be a single character")
if (verbose == 1L) cat("\nCycle 0 string has length ", nchar(init), "\n", sep = "")
if (verbose == 1L) cat("Cycle 0:", init, "\n")
curr <- init
out <- rep(NA_character_, n+1)
out[1] <- init
for (j in 1:n) {
RR <- vector("list")
for (i in 1:nrow(rules)) {
rr <- str_locate_all(curr, rules[i,1])
if (verbose > 1L) cat("Processing rule", i, "\n")
if (dim(rr[[1]])[1] == 0) {
if (verbose > 1L) cat("\tRule", i, "was not needed\n")
next
}
RR[i] <- rr
}
print(RR)
for (i in 1:length(RR)) {
tmp <- as.data.frame(RR[i])
tmp$insert <- rules[i,2]
RR[[i]] <- tmp
}
print(RR)
RRdf <- as.data.frame(RR[1])
for (i in 2:length(RR)) {
RRdf <- rbind(RRdf, as.data.frame(RR[i]))
}
if (verbose > 1L) print(RRdf)
curr <- unlist(strsplit(curr, ""))
curr[RRdf$start] <- RRdf$insert
curr <- paste0(curr, collapse = "")
out[j+1] <- curr
if (verbose == 1L) cat("\nCycle ", j, " string has length ", nchar(curr), "\n", sep = "")
if (verbose == 1L) cat("Cycle ", j, ": ", curr, "\n", sep = "")
}
if (retAll) return(out)
curr
}
|
predict.aster <- function(object, x, root, modmat, amat,
parm.type = c("mean.value", "canonical"),
model.type = c("unconditional", "conditional"),
is.always.parameter = FALSE,
se.fit = FALSE, info = c("expected", "observed"),
info.tol = sqrt(.Machine$double.eps), newcoef = NULL,
gradient = se.fit, ...)
{
parm.type <- match.arg(parm.type)
model.type <- match.arg(model.type)
info <- match.arg(info)
if (! object$converged)
stop("aster model fit not converged")
if (missing(modmat)) {
modmat <- object$modmat
x <- object$x
root <- object$root
}
setfam(object$famlist)
stopifnot(is.logical(se.fit))
stopifnot(length(se.fit) == 1)
stopifnot(is.logical(gradient))
stopifnot(length(gradient) == 1)
stopifnot(all(dim(modmat)[2:3] == dim(object$modmat)[2:3]))
stopifnot(all(dimnames(modmat)[[2]] == dimnames(object$modmat)[[2]]))
stopifnot(all(dimnames(modmat)[[3]] == dimnames(object$modmat)[[3]]))
if (parm.type == "mean.value") {
stopifnot(dim(root) == dim(modmat)[1:2])
if (model.type == "conditional") {
stopifnot(dim(x) == dim(modmat)[1:2])
}
}
if (parm.type == "mean.value") {
if (missing(root))
stop("parm.type == \"mean.value\" and root missing\n")
if (model.type == "conditional") {
if (missing(x))
stop("parm.type == \"mean.value\" && model.type == \"conditional\" and x missing\n")
}
}
if (! missing(amat)) {
if (is.array(amat)) {
if (length(dim(amat)) != 3)
stop("amat is array but not 3-dimensional")
if (! all(dim(amat)[1:2] == dim(modmat)[1:2]))
stop("amat is array but dimensions 1 and 2 do not match modmat")
} else {
if (is.matrix(amat)) {
if (dim(amat)[1] != prod(dim(modmat)[1:2]))
stop("amat is matrix but first dimension does not match dimensions 1 and 2 of modmat")
} else {
stop("amat is neither array nor matrix")
}
}
}
nind <- dim(modmat)[1]
nnode <- dim(modmat)[2]
ncoef <- dim(modmat)[3]
if (ncoef != length(object$coefficients))
stop("object$coefficients does not match dim(modmat)[3]")
if (se.fit) {
if (info == "expected")
infomat <- object$fisher
else
infomat <- object$hessian
fred <- eigen(infomat, symmetric = TRUE)
sally <- fred$values < max(fred$values) * info.tol
if (any(sally)) {
cat("apparent null eigenvectors of information matrix\n")
cat("directions of recession or constancy of log likelihood\n")
print(zapsmall(fred$vectors[ , sally]))
stop("cannot compute standard errors")
}
}
beta <- object$coefficients
if (! is.null(newcoef)) {
stopifnot(is.numeric(newcoef))
stopifnot(is.finite(newcoef))
stopifnot(length(newcoef) == length(object$coefficients))
beta <- newcoef
}
eta <- .C(C_aster_mat_vec_mult,
nrow = as.integer(nind * nnode),
ncol = as.integer(ncoef),
a = as.double(modmat),
b = as.double(beta),
c = matrix(as.double(0), nind, nnode))$c
origin <- object$origin
stopifnot(is.numeric(origin))
stopifnot(all(is.finite(origin)))
stopifnot(is.matrix(origin))
stopifnot(ncol(origin) == nnode)
origin.row <- origin[1, ]
origin <- matrix(origin.row, nrow = nind, ncol = nnode, byrow = TRUE)
eta <- eta + origin
pred <- object$pred
fam <- object$fam
if (parm.type == "canonical") {
if (model.type == object$type) {
zeta <- eta
if (se.fit | gradient)
gradmat <- matrix(modmat, ncol = ncoef)
} else {
if (model.type == "unconditional") {
zeta <- .C(C_aster_theta2phi,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
theta = as.double(eta),
phi = matrix(as.double(0), nind, nnode))$phi
if (se.fit | gradient)
gradmat <- .C(C_aster_D_beta2theta2phi,
nind = as.integer(nind),
nnode = as.integer(nnode),
ncoef = as.integer(ncoef),
pred = as.integer(pred),
fam = as.integer(fam),
theta = as.double(eta),
modmat = as.double(modmat),
gradmat = matrix(as.double(0), nind * nnode, ncoef)
)$gradmat
}
if (model.type == "conditional") {
zeta <- .C(C_aster_phi2theta,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
phi = as.double(eta),
theta = matrix(as.double(0), nind, nnode))$theta
if (se.fit | gradient)
gradmat <- .C(C_aster_D_beta2phi2theta,
nind = as.integer(nind),
nnode = as.integer(nnode),
ncoef = as.integer(ncoef),
pred = as.integer(pred),
fam = as.integer(fam),
theta = as.double(zeta),
modmat = as.double(modmat),
gradmat = matrix(as.double(0), nind * nnode, ncoef)
)$gradmat
}
}
} else {
if (model.type == "conditional" && object$type == "conditional") {
ctau <- .C(C_aster_theta2ctau,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
theta = as.double(eta),
ctau = matrix(as.double(0), nind, nnode))$ctau
xpred <- .C(C_aster_xpred,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
x = as.double(x),
root = as.double(root),
xpred = double(nind * nnode))$xpred
if (is.always.parameter) {
zeta <- ctau
} else {
zeta <- xpred * ctau
}
if (se.fit | gradient) {
grad.ctau <- .C(C_aster_theta2whatsis,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
deriv = as.integer(2),
theta = as.double(eta),
result = double(nind * nnode))$result
gradmat <- matrix(modmat, ncol = ncoef)
if (is.always.parameter) {
gradmat <- sweep(gradmat, 1, grad.ctau, "*")
} else {
gradmat <- sweep(gradmat, 1, xpred * grad.ctau, "*")
}
}
}
if (model.type == "unconditional" && object$type == "unconditional") {
theta <- .C(C_aster_phi2theta,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
phi = as.double(eta),
theta = matrix(as.double(0), nind, nnode))$theta
ctau <- .C(C_aster_theta2ctau,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
theta = as.double(theta),
ctau = matrix(as.double(0), nind, nnode))$ctau
zeta <- .C(C_aster_ctau2tau,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
root = as.double(root),
ctau = as.double(ctau),
tau = matrix(as.double(0), nind, nnode))$tau
if (se.fit | gradient)
gradmat <- .C(C_aster_D_beta2phi2tau,
nind = as.integer(nind),
nnode = as.integer(nnode),
ncoef = as.integer(ncoef),
pred = as.integer(pred),
fam = as.integer(fam),
beta = as.double(beta),
root = as.double(root),
origin = as.double(origin),
modmat = as.double(modmat),
gradmat = matrix(as.double(0), nind * nnode, ncoef))$gradmat
}
if (model.type == "conditional" && object$type == "unconditional") {
theta <- .C(C_aster_phi2theta,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
phi = as.double(eta),
theta = matrix(as.double(0), nind, nnode))$theta
ctau <- .C(C_aster_theta2ctau,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
theta = as.double(theta),
ctau = matrix(as.double(0), nind, nnode))$ctau
xpred <- .C(C_aster_xpred,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
x = as.double(x),
root = as.double(root),
xpred = matrix(as.double(0), nind, nnode))$xpred
if (is.always.parameter) {
zeta <- ctau
} else {
zeta <- xpred * ctau
}
if (se.fit | gradient) {
gradmat <- .C(C_aster_D_beta2phi2theta,
nind = as.integer(nind),
nnode = as.integer(nnode),
ncoef = as.integer(ncoef),
pred = as.integer(pred),
fam = as.integer(fam),
theta = as.double(theta),
modmat = as.double(modmat),
gradmat = matrix(as.double(0), nind * nnode, ncoef))$gradmat
grad.ctau <- .C(C_aster_theta2whatsis,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
deriv = as.integer(2),
theta = as.double(theta),
result = double(nind * nnode))$result
if (is.always.parameter) {
deltheta2xi <- grad.ctau
} else {
deltheta2xi <- as.numeric(xpred) * grad.ctau
}
gradmat <- sweep(gradmat, 1, deltheta2xi, "*")
}
}
if (model.type == "unconditional" && object$type == "conditional") {
ctau <- .C(C_aster_theta2ctau,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
theta = as.double(eta),
ctau = matrix(as.double(0), nind, nnode))$ctau
zeta <- .C(C_aster_ctau2tau,
nind = as.integer(nind),
nnode = as.integer(nnode),
pred = as.integer(pred),
fam = as.integer(fam),
root = as.double(root),
ctau = as.double(ctau),
tau = matrix(as.double(0), nind, nnode))$tau
if (se.fit | gradient)
gradmat <- .C(C_aster_D_beta2theta2tau,
nind = as.integer(nind),
nnode = as.integer(nnode),
ncoef = as.integer(ncoef),
pred = as.integer(pred),
fam = as.integer(fam),
beta = as.double(beta),
root = as.double(root),
modmat = as.double(modmat),
gradmat = matrix(as.double(0), nind * nnode, ncoef))$gradmat
}
}
clearfam()
result <- as.double(zeta)
if (! missing(amat)) {
amat <- matrix(amat, nrow = nind * nnode)
result <- as.numeric(t(amat) %*% result)
if (se.fit | gradient)
gradmat <- t(amat) %*% gradmat
}
if (! (se.fit | gradient)) {
return(result)
} else if (se.fit) {
fred <- .C(C_aster_diag_mat_mat_mat_mult,
nrow = nrow(gradmat),
ncol = ncol(gradmat),
a = as.double(gradmat),
b = as.double(solve(infomat)),
c = double(nrow(gradmat)))$c
return(list(fit = result, se.fit = sqrt(as.numeric(fred)),
gradient = gradmat))
} else {
return(list(fit = result, gradient = gradmat))
}
}
predict.aster.formula <- function(object, newdata, varvar, idvar, root, amat,
parm.type = c("mean.value", "canonical"),
model.type = c("unconditional", "conditional"),
is.always.parameter = FALSE,
se.fit = FALSE, info = c("expected", "observed"),
info.tol = sqrt(.Machine$double.eps), newcoef = NULL,
gradient = se.fit, ...)
{
parm.type <- match.arg(parm.type)
model.type <- match.arg(model.type)
info <- match.arg(info)
if (missing(newdata)) {
class(object) <- "aster"
return(NextMethod("predict"))
}
tt <- object$terms
mf <- match.call(expand.dots = FALSE)
m <- match(c("newdata", "varvar", "idvar", "root"), names(mf), 0)
mf <- mf[c(1, m)]
mf$drop.unused.levels <- TRUE
mf[[1]] <- as.name("model.frame")
mf$formula <- tt
mf$xlev <- object$xlevels
mf$data <- mf$newdata
mf$newdata <- NULL
mf <- eval.parent(mf)
mt <- attr(mf, "terms")
x <- model.response(mf, "numeric")
if (is.empty.model(mt)) {
stop("empty model")
} else {
modmat <- model.matrix(mt, mf)
}
varvar <- mf[["(varvar)"]]
idvar <- mf[["(idvar)"]]
root <- mf[["(root)"]]
nind <- length(unique(idvar))
nnode <- length(unique(varvar))
if (nind * nnode != length(varvar))
stop("nrow(data) not nind * nnode")
varvarmat <- matrix(as.vector(varvar), nind, nnode)
idvarmat <- matrix(as.vector(idvar), nind, nnode)
foo <- apply(varvarmat, 2, function(x) length(unique(x)))
bar <- apply(idvarmat, 1, function(x) length(unique(x)))
if (! (all(foo == 1) & all(bar == 1)))
stop("data not nind by nnode matrix with rows individuals and columns variables")
varlab <- varvarmat[1, ]
idlab <- idvarmat[ , 1]
if (all(idlab == seq(along = idlab)))
idlab <- NULL
if (! is.numeric(x))
stop("response not numeric")
if (length(x) != nind * nnode)
stop("response not nind by nnode matrix with rows individuals and columns variables")
x <- matrix(x, nind, nnode)
dimnames(x) <- list(idlab, varlab)
if (! is.numeric(root))
stop("root not numeric")
if (length(root) != nind * nnode)
stop("root not nind by nnode matrix with rows individuals and columns variables")
root <- matrix(root, nind, nnode)
dimnames(root) <- list(idlab, varlab)
if (! is.numeric(root))
stop("root not numeric")
if (length(root) != nind * nnode)
stop("root not nind by nnode matrix with rows individuals and columns variables")
root <- matrix(root, nind, nnode)
dimnames(root) <- list(idlab, varlab)
if (! is.numeric(modmat))
stop("model matrix not numeric")
if (! is.matrix(modmat))
stop("model matrix not matrix")
if (nrow(modmat) != nind * nnode)
stop("nrow of model matrix not nind * nnode")
coeflab <- dimnames(modmat)[[2]]
objcoeflab <- names(object$coefficients)
if (! all(is.element(objcoeflab, coeflab)))
stop("regression coefficients do not match in object and new model matrix")
inies <- is.element(coeflab, objcoeflab)
modmat <- modmat[ , inies]
coeflab <- dimnames(modmat)[[2]]
ncoef <- length(coeflab)
modmat <- array(as.numeric(modmat), c(nind, nnode, ncoef))
dimnames(modmat) <- list(idlab, varlab, coeflab)
if (missing(amat)) {
foo <- predict.aster(object, x, root, modmat,
parm.type = parm.type, model.type = model.type,
is.always.parameter = is.always.parameter,
se.fit = se.fit, info = info, info.tol = info.tol,
newcoef = newcoef, gradient = gradient, ...)
} else {
foo <- predict.aster(object, x, root, modmat, amat,
parm.type = parm.type, model.type = model.type,
is.always.parameter = is.always.parameter,
se.fit = se.fit, info = info, info.tol = info.tol,
newcoef = newcoef, gradient = gradient, ...)
}
if (is.list(foo)) {
foo$modmat <- modmat
}
return(foo)
} |
llsearch.D <-function(x, y, n, jlo, jhi, klo, khi,plot)
{
fjk <- matrix(0, n, n)
fxy <- matrix(0, (jhi - jlo + 1), (khi - klo + 1))
jkgrid <- expand.grid(jlo:jhi, klo:khi)
res <- data.frame(j = jkgrid[,1],
k = jkgrid[,2],
k.ll = apply(jkgrid, 1, p.estFUN.D, x = x,
y = y, n = n))
fxy <- matrix(res$k.ll, nrow = jhi-jlo+1, ncol = khi-klo+1)
rownames(fxy) <- jlo:jhi
colnames(fxy) <- klo:khi
if (plot == "TRUE") {
jx<-jlo:jhi
ky<-klo:khi
persp(jx, ky, fxy, xlab = "j", ylab = "k", zlab = "LL(x,y,j,k)")
title("Log-likelihood Surface")
}
z <- findmax(fxy)
jcrit <- z$imax + jlo - 1
kcrit <- z$jmax + klo - 1
list(jhat = jcrit, khat = kcrit, value = max(fxy))
}
p.estFUN.D <- function(jk, x, y, n){
j = jk[1]
k = jk[2]
a <- p.est.D(x,y,n,j,k)
s2 <- a$sigma2
t2 <- a$tau2
u2 <- a$u2
return(p.ll.D(n, j, k, s2, t2, u2))
}
p.est.D <-function(x,y,n,j,k){
xa<-x[1:j]
ya<-y[1:j]
jp1 <- j+1
xb <- x[jp1:k]
yb <- y[jp1:k]
kp1 <- k+1
xc <- x[kp1:n]
yc <- y[kp1:n]
g1 <- lm(ya ~ xa)
g2 <- lm(yb ~ xb)
g3 <- lm(yc ~ xc)
beta <- c(g1$coef[1],g1$coef[2],g2$coef[1],g2$coef[2],g3$coef[1],g3$coef[2])
s2 <- sum((ya-g1$fit)^2)/j
t2 <- sum((yb-g2$fit)^2)/(k-j)
u2 <- sum((yc-g3$fit)^2)/(n-k)
list(a0=beta[1],a1=beta[2],b0=beta[3],b1=beta[4],c0=beta[5],c1=beta[6],sigma2=s2,tau2=t2,u2=u2,xj=x[j],xk=x[k])
}
p.ll.D<-function(n, j, k, s2, t2, u2){
q1 <- n * log(sqrt(2 * pi))
q2 <- 0.5 * (j) * (1 + log(s2))
q3 <- 0.5 * (k - j) * (1 + log(t2))
q4 <- 0.5*(n-k)*(1+log(u2))
- (q1 + q2 + q3 + q4)
}
findmax <-function(a)
{
maxa<-max(a)
imax<- which(a==max(a),arr.ind=TRUE)[1]
jmax<-which(a==max(a),arr.ind=TRUE)[2]
list(imax = imax, jmax = jmax, value = maxa)
} |
prep_odds_against <- function(dat,
x_axis,
groupings = NULL) {
{ if (!tibble::is_tibble(dat)) {
base::stop("dat must be a tibble")
}
if (!base::is.character(x_axis)) {
base::stop("x_axis must be a string indicating the x-axis variable")
}
if (!base::all(base::is.character(groupings)) & !base::is.null(groupings)) {
base::stop("groupings must be a character or vector of characters for column names")
} }
new_col <- glue::glue("{x_axis}_against")
dat <- dat %>%
dplyr::group_by_at(dplyr::vars(dplyr::one_of(groupings))) %>%
dplyr::mutate(!!{{ new_col }} := (1 - .data[[x_axis]]) / (.data[[x_axis]])) %>%
dplyr::arrange(.data[[new_col]],
.by_group = TRUE
)
base::return(dat)
} |
knitr::opts_chunk$set(warning = FALSE, message = TRUE)
library(ggplot2)
library(ggshadow)
library(ggshadow)
ggplot(economics_long, aes(date, value01, colour = variable)) + geom_shadowline()
library(ggshadow)
ggplot(economics_long, aes(date, value01, group = variable, colour=value01, shadowcolor='grey', shadowalpha=0.5, shadowsize=5*(1-value01))) + geom_shadowline()
ggplot(mtcars, aes(wt, mpg)) + geom_shadowpoint(aes( color = carb, shadowcolour = ifelse(vs == 1, 'red', 'blue') )) |
bufferforsiland<-function(d,sfGIS,loc.sf,landnames,border=F)
{
if(class(loc.sf)[1]!="sf")
{
loc.sf=st_as_sf(as.data.frame(loc.sf),coords = c("X","Y"))
st_crs(loc.sf)<-st_crs(sfGIS)
}
if(length(d) != length(landnames))
stop("length(d) and length(landnames) have to be equal")
n=nrow(loc.sf)
nvar=length(landnames)
matBuffer=matrix(0,nrow=n,ncol=nvar)
for(k in 1:nvar)
{
if(!border)
{
geom_buff=st_geometry(st_buffer(loc.sf,d[k]))
ll=list(NULL)
for(i in 1:length(geom_buff))
{
ll[[i]]=geom_buff[i]
}
}
if(border)
{
options(warn=-1)
stinter=sf::st_intersects(loc.sf,sfGIS)
options(warn=0)
loc2gis=unlist(lapply(stinter,function(x){if(length(x)==1) return(x) else return(-1000)} ))
numerr=c(1:length(loc2gis))[loc2gis==-1000]
if(sum(loc2gis==-1000)>0)
{
locerr=c(1:length(loc2gis))[loc2gis==-1000]
cat("problem with observations : \n")
print(locerr)
stop("Some observations are not located inside polygons.")
}
geom_buff=st_geometry(st_buffer(sfGIS$geometry[loc2gis],d[k]))
geom_buff0=st_geometry(st_buffer(sfGIS$geometry[loc2gis],0))
ll=list(NULL)
for(i in 1:length(geom_buff))
{
ll[[i]]=st_make_valid(st_difference(geom_buff[i],geom_buff0[i]))
if(st_is_empty(ll[[i]]))
stop("stop empty 1")
}
}
areaBuff=unlist(lapply(ll,function(x){
res=sum(st_area(x))
if(length(res)==0)
return(0)
else
return(res)
}))
currentland=st_make_valid(st_geometry(sfGIS[unlist(sfGIS[landnames[k]]) ==1,]))
listArea=lapply(ll,function(x){uu=st_intersection(x,currentland)
res=as.numeric(sum(st_area(uu)))
if(length(res)==0)
return(0)
else
return(res)
})
Areavector=unlist(listArea)
ind=c(areaBuff!=0)
propBuffer=rep(0,length(areaBuff))
propBuffer[ind]=Areavector[ind]/areaBuff[ind]
matBuffer[,k]=propBuffer
}
colnames(matBuffer)=landnames
invisible(return(matBuffer))
} |
getCommonPrefix <- function(strs, suffix=FALSE, ...) {
nchars <- sapply(strs, FUN=nchar)
chars <- strsplit(strs, split="")
if (suffix) {
chars <- lapply(chars, FUN=rev)
}
naValue <- NA_character_
data <- matrix(naValue, nrow=length(chars), ncol=max(nchars))
for (kk in seq_along(chars)) {
cc <- seq_len(nchars[kk])
data[kk,cc] <- chars[[kk]]
}
count <- 0
for (cc in seq_len(ncol(data))) {
uchars <- unique(data[,cc])
if (length(uchars) > 1)
break
count <- cc
}
prefix <- chars[[1]][seq_len(count)]
if (suffix) {
prefix <- rev(prefix)
}
prefix <- paste(prefix, collapse="")
prefix
} |
call(3,
b = 2, c
)
gs(3,
b = 2,
c
)
call(3, b = 2, c)
map(data, fun,
x = 3, z = 33
)
map2(
dat1, data2, fun, x, y,
z
)
map2(dat1, data2, fun,
x = 1, y = 2,
z
) |
dccLink <- function(children=NULL, id=NULL, href=NULL, refresh=NULL, className=NULL, style=NULL, title=NULL, target=NULL, loading_state=NULL) {
props <- list(children=children, id=id, href=href, refresh=refresh, className=className, style=style, title=title, target=target, loading_state=loading_state)
if (length(props) > 0) {
props <- props[!vapply(props, is.null, logical(1))]
}
component <- list(
props = props,
type = 'Link',
namespace = 'dash_core_components',
propNames = c('children', 'id', 'href', 'refresh', 'className', 'style', 'title', 'target', 'loading_state'),
package = 'dashCoreComponents'
)
structure(component, class = c('dash_component', 'list'))
} |
rbenttest <- function(y, z, x, NB = 1000, myseed = 1 ){
wilcoxon <- function(t){
sqrt(12)*(t-0.5)
}
testFun <- function(tau){
n <- length(y)
xz <- cbind(z, x)
fit.rank <- rfit(y~ xz-1)
res.rank <- as.vector(residuals(fit.rank))
phi.res <- wilcoxon(rank(res.rank)/(n+1))
Rn.rank <- rep(0, length(tau))
for (kk in 1:length(tau)){
Rn.rank[kk] <- 1/sqrt(n)*sum(
phi.res*(x-tau[kk])*ifelse(x<=tau[kk], 1, 0)
)
}
Tn.rank <- max(abs(Rn.rank))
return(Tn.rank)
}
testFun.resample <- function(tau){
n<- length(y)
e <- rnorm(n, 0, 1)
B <- runif(n, 0, 1)
v <- (-1)*(B<=0.5) +1*(B>0.5)
ve <- v*e
xz <- cbind(z, x)
Sn <- (t(xz)%*%xz)/n
xc <- xz - mean(xz)
Sn.rank <- mean(xc^2)
fit.rank <- rfit(y~ xz-1)
res.rank <- as.vector(residuals(fit.rank))
h <- 1.06* n^(-1/5)* sd(res.rank)
pdf<- approxfun(density(res.rank, kernel= "epanechnikov", bw=h))
fe.rank <- pdf(res.rank)
cdf <- ecdf(res.rank)
Fe.rank <- cdf(res.rank)
taus <- fit.rank$taushat
tauphi <- fit.rank$tauhat
Rn.rank <- rep(0, length(tau))
for (kk in 1:length(tau)){
Sn.rank.tau <- apply(
sqrt(12)*fe.rank*xz*(x-tau[kk])*ifelse(x<= tau[kk], 1, 0), 2, mean
)
Rn.rank[kk] <- 1/sqrt(n)*sum(
ve*(
wilcoxon(Fe.rank)*(x-tau[kk])*ifelse(x<= tau[kk],1,0)-
wilcoxon(Fe.rank)* tauphi* xz%*% solve(Sn) %*% Sn.rank.tau
)
)
}
Tn.rank <- max(abs(Rn.rank))
return(Tn.rank)
}
set.seed(myseed)
tau <- seq(min(x)+0.01, max(x)-0.01, length=100)
Tn <- testFun(tau)
Tn.NB <- replicate(NB, testFun.resample(tau))
pv <- mean(Tn.NB >Tn, na.rm=TRUE)
return(list(Tn = Tn, Tn.NB = Tn.NB, p.value = pv))
} |
NULL
emmeans_test <- function(data, formula, covariate = NULL, ref.group = NULL,
comparisons = NULL, p.adjust.method = "bonferroni",
conf.level = 0.95, model = NULL, detailed = FALSE){
. <- NULL
covariate <- rlang::enquos(covariate = covariate) %>%
get_quo_vars_list(data, .) %>% unlist()
args <- as.list(environment()) %>%
.add_item(method = "emmeans_test")
required_package("emmeans")
outcome <- get_formula_left_hand_side(formula)
rhs <- group <- get_formula_right_hand_side(formula)
grouping.vars <- NULL
if(is_grouped_df(data)){
grouping.vars <- dplyr::group_vars(data)
rhs <- c(grouping.vars, rhs) %>%
paste(collapse = "*")
data <- dplyr::ungroup(data)
}
if(!is.null(covariate)){
covariate <- paste(covariate, collapse = "+")
rhs <- paste(covariate, rhs, sep = "+")
}
data <- data %>% .as_factor(group, ref.group = ref.group)
group.levels <- data %>% get_levels(group)
formula <- stats::as.formula(paste(outcome, rhs, sep = " ~ "))
if(is.null(model))
model <- stats::lm(formula, data)
if (is.null(comparisons)) {
comparisons <- get_comparisons(data, variable = !!group, ref.group = !!ref.group)
}
method <- get_emmeans_contrasts(data, group, comparisons)
formula.emmeans <- stats::as.formula(paste0("~", rhs))
res.emmeans <- emmeans::emmeans(model, formula.emmeans)
comparisons <- pairwise_emmeans_test(
res.emmeans, grouping.vars, method = method,
p.adjust.method = p.adjust.method,
conf.level = conf.level
)
res.emmeans <- res.emmeans %>%
tibble::as_tibble() %>%
dplyr::arrange(!!!syms(grouping.vars)) %>%
dplyr::rename(se = .data$SE, conf.low = .data$lower.CL, conf.high = .data$upper.CL) %>%
mutate(method = "Emmeans test")
if(!detailed){
to.remove <- c("estimate", "estimate1", "estimate2", "se", "conf.low", "conf.high", "method", "null.value")
to.keep <- setdiff(colnames(comparisons), to.remove)
comparisons <- comparisons[, to.keep]
}
comparisons %>%
add_column(.y. = outcome, .before = "group1") %>%
set_attrs(args = args, emmeans = res.emmeans) %>%
add_class(c("rstatix_test", "emmeans_test"))
}
get_emmeans <- function(emmeans.test){
if(!inherits(emmeans.test, "emmeans_test")){
stop("An object of class 'emmeans_test' required.")
}
attr(emmeans.test, "emmeans")
}
pairwise_emmeans_test <- function(res.emmeans, grouping.vars = NULL, method = "pairwise",
p.adjust.method = "bonferroni", conf.level = 0.95){
comparisons <- emmeans::contrast(
res.emmeans, by = grouping.vars, method = method,
adjust = "none"
)
comparisons <- tidy(comparisons, conf.int = TRUE, conf.level = conf.level)
comparisons <- comparisons %>%
tidyr::separate(col = "contrast", into = c("group1", "group2"), sep = "-") %>%
dplyr::rename(se = .data$std.error, p = .data$p.value) %>%
dplyr::select(!!!syms(grouping.vars), everything())
p.adjusted <- emmeans::contrast(
res.emmeans, by = grouping.vars, method = method,
adjust = p.adjust.method
) %>%
as.data.frame() %>%
pull("p.value")
comparisons <- comparisons %>%
mutate(p.adj = p.adjusted) %>%
add_significance("p.adj")
comparisons %>%
dplyr::arrange(!!!syms(grouping.vars))
}
get_emmeans_contrasts <- function(data, group, comparisons){
get_dummy_code <- function(level, group.levels){
dummy.code <- rep(0, length(group.levels))
lev.pos <- which(group.levels == level)
dummy.code[lev.pos] <- 1
dummy.code
}
make_emmeans_contrast <- function(groups, contrasts.list ){
group1 <- groups[1]
group2 <- groups[2]
contrasts.list[[group1]]-contrasts.list[[group2]]
}
make_comparison_name <- function(groups){
paste(groups[1], groups[2], sep = "-")
}
group.levels <- get_levels(data, group)
contrasts.list <- group.levels %>%
map(get_dummy_code, group.levels)
names(contrasts.list) <- group.levels
comparison.contrasts <- comparisons %>%
map(make_emmeans_contrast, contrasts.list)
comparison.names <- comparisons %>% map(make_comparison_name)
names(comparison.contrasts) <- comparison.names
comparison.contrasts
} |
steepest <- function(K,y,theta){
foo <- function(x,K,y,theta,gv) {
get.l(theta+x*gv, K, y)
}
gv <- get.gl(theta,K,y)$grad
gv <- gv/sqrt(sum(gv^2))
poop <- optimize(foo,c(-1,1),maximum=TRUE,K=K,y=y,
theta=theta,gv=gv)
con <- poop$maximum
theta + con*gv
} |
kpAddCytobandsAsLine <- function(karyoplot, color.table=NULL, color.schema='only.centromeres', lwd=3, lend=1, clipping=TRUE, ...) {
if(missing(karyoplot)) stop("The parameter 'karyoplot' is required")
if(!methods::is(karyoplot, "KaryoPlot")) stop("'karyoplot' must be a valid 'KaryoPlot' object")
if(!is.null(karyoplot$cytobands) && length(karyoplot$cytobands)>0) {
cyto <- karyoplot$cytobands
} else {
cyto <- karyoplot$genome
mcols(cyto) <- data.frame(name=seqnames(cyto), gieStain="gpos50", stringsAsFactors=FALSE)
}
if(!methods::is(cyto, "GRanges")) stop("'cytobands' must be a GRanges object")
if(!("gieStain" %in% colnames(mcols(cyto)))) {
warning("No 'gieStain' column found in cytobands. Using 'gpos50' (gray) for all of them")
mcols(cyto) <- cbind(mcols(cyto), gieStain="gpos50")
}
cyto <- filterChromosomes(cyto, keep.chr = karyoplot$chromosomes)
karyoplot$beginKpPlot()
on.exit(karyoplot$endKpPlot())
ccf <- karyoplot$coord.change.function
pp <- karyoplot$plot.params
mids <- karyoplot$ideogram.mid
color.table <- getCytobandColors(color.table, color.schema)
ybottom <- mids(as.character(seqnames(cyto)))
ytop <- mids(as.character(seqnames(cyto)))
xleft <- ccf(x=start(cyto), chr=as.character(seqnames(cyto)), data.panel="ideogram")$x
xright <- ccf(x=end(cyto), chr=as.character(seqnames(cyto)), data.panel="ideogram")$x
col <- color.table[as.character(cyto$gieStain)]
if(karyoplot$zoom==TRUE) {
if(clipping==TRUE) {
clip.xleft <- ccf(x=start(karyoplot$plot.region), chr=as.character(seqnames(karyoplot$plot.region)), data.panel="ideogram")$x
clip.xright <- ccf(x=end(karyoplot$plot.region), chr=as.character(seqnames(karyoplot$plot.region)), data.panel="ideogram")$x
clip.ybottom <- ybottom - 10
clip.ytop <- ytop + 10
graphics::clip(x1 = clip.xleft, x2 = clip.xright, y1 = clip.ybottom, y2=clip.ytop)
}
}
graphics::segments(x0 = xleft, x1=xright, y0=ybottom, y1=ytop, col=col, lwd=lwd, lend=lend)
invisible(karyoplot)
} |
context("test-caesar-cipher")
test_that("Caesar encryption works", {
expect_equal(caesar("Experience is the teacher of all things.",
shift = 3),
"HAshulhqfhclvcwkhcwhdfkhucricdoocwklqjva")
expect_equal(caesar(c("Experience is the teacher of all things.",
"The best way of avenging thyself is not to become like the wrong doer."),
shift = 3),
c("HAshulhqfhclvcwkhcwhdfkhucricdoocwklqjva",
"WkhcehvwczdBcricdyhqjlqjcwkBvhoiclvcqrwcwrcehfrphcolnhcwkhczurqjcgrhua"))
expect_equal(caesar("Experience is the teacher of all things.",
shift = 0),
"Experience is the teacher of all things.")
expect_equal(caesar("Experience is the teacher of all things.",
shift = 5),
"JCujwnjshjenxeymjeyjfhmjwetkefqqeymnslxc")
expect_equal(caesar("Experience is the teacher of all things.",
shift = -10),
"unf<h/<d:<{/i{j.<{j<}:.<h{e>{}bb{j./d,i[")
expect_equal(caesar("It is easier to find men who will volunteer to die, than to find those who are willing to endure pain with patience.",
shift = 15),
"XIoxHotpHxtGoIDouxCsoBtCoLwDoLxAAoKDAJCIttGoIDosxtloIwpCoIDouxCsoIwDHtoLwDopGtoLxAAxCvoIDotCsJGtoEpxCoLxIwoEpIxtCrtm")
expect_equal(caesar("It is easier to find men who will volunteer to die, than to find those who are willing to endure pain with patience.",
shift = -17),
"rc_;b_[+b;[a_c._];,~_>[,_f}._f;<<_e.<d,c[[a_c._~;[(_c}+,_c._];,~_c}.b[_f}._+a[_f;<<;,{_c._[,~da[_/+;,_f;c}_/+c;[,`[)")
expect_equal(caesar("What we wish, we readily believe, and what we ourselves think, we imagine others think also. 123 !@
shift = -17),
"F}+c_f[_f;b}(_f[_a[+~;<h_=[<;[e[(_+,~_f}+c_f[_.dab[<e[b_c};,'(_f[_;>+{;,[_.c}[ab_c};,'_+<b.)_KLM_TUV")
expect_equal(caesar("What we wish, we readily believe, and what we ourselves think, we imagine others think also. 123 !@
shift = 1),
"Xibuaxfaxjti.axfasfbejmzacfmjfwf.aboeaxibuaxfapvstfmwftauijol.axfajnbhjofapuifstauijolabmtp/a234a@
expect_equal(caesar("Veni, vidi, vici. (I came, I saw, I conquered.)",
shift = 1),
"Wfoj.awjej.awjdj/a)Jadbnf.aJatbx.aJadporvfsfe/-")
expect_equal(caesar("Veni, vidi, vici. (I came, I saw, I conquered.)",
shift = 5),
"0jsnbeAninbeAnhnce=NehfrjbeNexfBbeNehtsvzjwjic`")
expect_equal(caesar("Veni, vidi, vici. (I came, I saw, I conquered.)",
shift = 100),
"4nwrfiErmrfiErlrgi]RiljvnfiRiBjFfiRilxwzDnAnmg{")
expect_equal(caesar("Veni, vidi, vici. (I came, I saw, I conquered.)",
shift = 1500),
"aW50OR$0V0OR$0U0PRx[RUS4WOR[R!S%OR[RU658
expect_equal(caesar("Veni, vidi, vici. (I came, I saw, I conquered.)",
shift = -100),
"M>e [}m < [}m ' ]}9z}';d>[}z}j;n[}z}'fehl>i><]!")
expect_equal(caesar("Veni, vidi, vici. (I came, I saw, I conquered.)",
shift = -123),
"p@-^36{^!^36{^9^46Mc697)@36c6~7}36c69_-=]@`@!4N")
})
test_that("Caesar deencryption works", {
expect_equal(caesar("HAshulhqfhclvcwkhcwhdfkhucricdoocwklqjva",
shift = 3,
decrypt = TRUE),
"Experience is the teacher of all things.")
expect_equal(caesar("Experience is the teacher of all things.",
shift = 0,
decrypt = TRUE),
"Experience is the teacher of all things.")
expect_equal(caesar("JCujwnjshjenxeymjeyjfhmjwetkefqqeymnslxc",
shift = 5,
decrypt = TRUE),
"Experience is the teacher of all things.")
expect_equal(caesar("unf<h/<d:<{/i{j.<{j<}:.<h{e>{}bb{j./d,i[",
shift = -10,
decrypt = TRUE),
"Experience is the teacher of all things.")
expect_equal(caesar("XIoxHotpHxtGoIDouxCsoBtCoLwDoLxAAoKDAJCIttGoIDosxtloIwpCoIDouxCsoIwDHtoLwDopGtoLxAAxCvoIDotCsJGtoEpxCoLxIwoEpIxtCrtm",
shift = 15,
decrypt = TRUE),
"It is easier to find men who will volunteer to die, than to find those who are willing to endure pain with patience.")
expect_equal(caesar("rc_;b_[+b;[a_c._];,~_>[,_f}._f;<<_e.<d,c[[a_c._~;[(_c}+,_c._];,~_c}.b[_f}._+a[_f;<<;,{_c._[,~da[_/+;,_f;c}_/+c;[,`[)",
shift = -17,
decrypt = TRUE),
"It is easier to find men who will volunteer to die, than to find those who are willing to endure pain with patience.")
expect_equal(caesar("F}+c_f[_f;b}(_f[_a[+~;<h_=[<;[e[(_+,~_f}+c_f[_.dab[<e[b_c};,'(_f[_;>+{;,[_.c}[ab_c};,'_+<b.)_KLM_TUV",
shift = -17,
decrypt = TRUE),
"What we wish, we readily believe, and what we ourselves think, we imagine others think also. 123 !@
expect_equal(caesar("Xibuaxfaxjti.axfasfbejmzacfmjfwf.aboeaxibuaxfapvstfmwftauijol.axfajnbhjofapuifstauijolabmtp/a234a@
shift = 1,
decrypt = TRUE),
"What we wish, we readily believe, and what we ourselves think, we imagine others think also. 123 !@
expect_equal(caesar("Wfoj.awjej.awjdj/a)Jadbnf.aJatbx.aJadporvfsfe/-",
shift = 1,
decrypt = TRUE),
"Veni, vidi, vici. (I came, I saw, I conquered.)")
expect_equal(caesar("0jsnbeAninbeAnhnce=NehfrjbeNexfBbeNehtsvzjwjic`",
shift = 5,
decrypt = TRUE),
"Veni, vidi, vici. (I came, I saw, I conquered.)")
expect_equal(caesar("4nwrfiErmrfiErlrgi]RiljvnfiRiBjFfiRilxwzDnAnmg{",
shift = 100,
decrypt = TRUE),
"Veni, vidi, vici. (I came, I saw, I conquered.)")
expect_equal(caesar("aW50OR$0V0OR$0U0PRx[RUS4WOR[R!S%OR[RU658
shift = 1500,
decrypt = TRUE),
"Veni, vidi, vici. (I came, I saw, I conquered.)")
expect_equal(caesar("M>e [}m < [}m ' ]}9z}';d>[}z}j;n[}z}'fehl>i><]!",
shift = -100,
decrypt = TRUE),
"Veni, vidi, vici. (I came, I saw, I conquered.)")
expect_equal(caesar("p@-^36{^!^36{^9^46Mc697)@36c6~7}36c69_-=]@`@!4N",
shift = -123,
decrypt = TRUE),
"Veni, vidi, vici. (I came, I saw, I conquered.)")
}) |
test_that("egor32 has factor vars", {
expect_s3_class(egor32$ego$variables$sex, "factor")
expect_s3_class(egor32$ego$variables$age, "factor")
expect_s3_class(egor32$alter$sex, "factor")
expect_s3_class(egor32$alter$age, "factor")
})
test_that("egor32: ego-level is active", {
expect_equal(attr(egor32, "active"), "ego")
}) |
context("String manipulation utilities")
test_that("substr2 edge cases", {
expect_identical(substr2("1234567890", 1, 1), "")
expect_identical(substr2("1234567890", 0, 0), "")
expect_identical(substr2("1234567890", 99, 100), "")
expect_identical(substr2("1234567890", 9, 100), "90")
expect_identical(substr2("1234567890", c(1,3)), "12")
expect_identical(substr2("1234567890", c(1,3), c(2,4)), c("1", "3"))
expect_identical(substr2("1234567890", c(1,2), 3), c("12", "2"))
expect_identical(substr2("1234567890", -3, 2), "1")
expect_error(substr2(c("abc", "def"), 1, 3))
})
test_that("gfsub basics", {
expect_identical(
gfsub("abcdefghijklmnopqrstuvwxyz", "[aeiouy]", toupper),
"AbcdEfghIjklmnOpqrstUvwxYz"
)
gfsub("&", "&(.*?);", function(match, entity) {
expect_identical(entity, "amp")
NULL
})
output <- gfsub("hello & goodbye", "&(.*?);", function(match, entity, bad_param) {
expect_error(bad_param)
NULL
})
expect_identical(output, "hello goodbye")
}) |
calculate_irr_periods <-
function(dates = c(
"2016-06-01",
"2017-05-31",
"2018-05-31",
"2019-05-31",
"2020-05-31",
"2021-05-31",
"2022-05-31",
"2023-05-31",
"2024-05-31",
"2025-05-31",
"2026-05-31"
),
cash_flows = c(
3000,
-478.515738547242,
-478.515738547242,
-478.515738547242,
-478.515738547242,
-478.515738547242,
-478.515738547242,
-478.515738547242,
-478.515738547242,
-478.515738547242,
-478.515738547278
),
date_format = '%Y-%m-%d',
scale_to_100 = F,
return_percentage = F,
return_df = T,
return_wide = T,
return_message = T) {
secant <-
function(par,
fn,
tol = 1.e-07,
itmax = 100,
trace = TRUE,
...) {
if (length(par) != 2)
stop("You must specify a starting parameter vector of length 2")
p.2 <- par[1]
p.1 <- par[2]
f <- rep(NA, length(par))
f[1] <- fn(p.1, ...)
f[2] <- fn(p.2, ...)
iter <- 1
pchg <- abs(p.2 - p.1)
fval <- f[2]
if (trace)
while (pchg >= tol & abs(fval) > tol & iter <= itmax) {
p.new <- p.2 - (p.2 - p.1) * f[2] / (f[2] - f[1])
pchg <- abs(p.new - p.2)
fval <- fn(p.new, ...)
p.1 <- p.2
p.2 <- p.new
f[1] <- f[2]
f[2] <- fval
iter <- iter + 1
}
list(par = p.new,
value = fval,
iter = iter)
}
npv <-
function (irr, cashFlow, times)
sum(cashFlow / (1 + irr) ^ times)
cfDate <-
dates %>%
as.Date(format = date_format)
times <-
difftime(cfDate, cfDate[1], units = "days") %>% as.numeric() / 365.24
s <-
secant(
par = c(0, 0.1),
fn = npv,
cashFlow = cash_flows,
times = times
)
irr <-
s$par
if (return_percentage == T & scale_to_100 == T) {
stop("Sorry you cannot return a percentage and scale to 100")
}
if (return_percentage) {
irr <-
irr %>% formattable::percent()
}
if (scale_to_100) {
irr <-
irr * 100
}
dateStart <-
min(dates) %>% ymd
dateEnd <-
max(dates) %>% ymd
equityContributions <-
cash_flows[cash_flows > 0] %>%
sum() %>%
formattable::currency(digits = 2)
equityDistributions <-
cash_flows[cash_flows < 0] %>%
sum() %>%
formattable::currency(digits = 2)
multipleCapital <-
(abs(equityDistributions) / equityContributions) %>% digits(digits = 3)
amountProfit <-
-(equityDistributions + equityContributions)
if (return_df)
data <-
tibble(
dateStart,
dateEnd,
equityContributions,
equityDistributions,
pctIRR = irr,
amountProfit,
multipleCapital,
dateTimeCF = Sys.time()
) %>%
mutate(pctIRR = percent(pctIRR, digits = 3))
else {
data <-
irr
}
if (return_message) {
"\nCash Flow Produces a " %>%
paste0(
formattable::percent(irr, digits = 3),
' IRR\nFrom ',
dateStart,
' to ',
dateEnd,
'\n',
'Profit of ',
formattable::currency(amountProfit, digits = 2),
'\nCapital Multiple of ',
multipleCapital,
"\n"
) %>%
cat(fill = T)
}
if (!return_wide) {
data <-
data %>%
gather(metric, value, -c(dateStart, dateEnd, dateTimeCF))
}
return(data)
}
calculate_cash_flow_dates <-
function(dates = c(
"2016-09-01",
"2017-08-31",
"2018-08-31",
"2019-08-31",
"2020-08-31",
"2021-08-31",
"2022-08-31",
"2023-08-31"
),
cash_flows = c(
-4151601,
119499.036215643,
257186.036215643,
447646.036215643,
200652.036215643,
510409.036215643,
193.036215643166,
8788626.76409155
),
working_capital = 125000,
remove_cumulative_cols = TRUE,
include_final_day = TRUE,
is_annual_budget = T,
distribution_frequency = NA) {
distribution_frequencies <-
c(NA,
'weekly',
'monthly',
'quarterly',
'yearly',
'sale')
distribution_frequency <-
distribution_frequency %>% str_to_lower() %>%
str_replace_all('yearly', 'annually') %>% str_replace_all('residual', 'sale')
if (!distribution_frequency %>% str_to_lower() %in% distribution_frequencies) {
distribution_frequency <- 'annually'
}
dates <-
dates %>%
ymd()
is_annual_budget <-
as.numeric((dates[2] - dates[1] + 1)) %%
364 == 1
if (distribution_frequency %in% c(NA, 'sale')) {
is_at_sale <-
T
} else {
is_at_sale <-
F
}
distribution_dates_df <-
tibble(date = dates) %>%
mutate(idPeriod = 0:(nrow(.) - 1))
distribution_dates_df <-
distribution_dates_df %>%
mutate(
isDistribution =
case_when(
(
idPeriod > 0 &
is_annual_budget == T &
(!distribution_frequency == 'sale')
) ~ T,
(
is_at_sale == T &
distribution_dates_df$idPeriod == max(distribution_dates_df$idPeriod)
) ~ T,
NA ~ F
))
distribution_dates_df <-
distribution_dates_df %>%
mutate_at('isDistribution',
funs(ifelse(isDistribution %>% is.na(), FALSE, .) %>% as.numeric()))
if (working_capital > 0) {
working_capital <-
-working_capital
}
cf_data <-
tibble(date = dates %>% ymd(),
cashFlow = cash_flows %>% currency(digits = 2)) %>%
mutate(idPeriod = 0:(nrow(.) - 1)) %>%
dplyr::select(idPeriod, everything()) %>%
left_join(distribution_dates_df) %>%
suppressMessages()
cf_data <-
cf_data %>%
mutate(
isSalePeriod = if_else(idPeriod == max(idPeriod), T, F),
workingCapital =
case_when(
cf_data$idPeriod == 0 ~ working_capital,
cf_data$idPeriod == max(cf_data$idPeriod) ~ -working_capital,
TRUE ~ 0
),
totalCF = workingCapital + cashFlow,
capitalContribution = if_else(totalCF < 0, -totalCF, 0),
cashAvailableDistribution = if_else(totalCF > 0, -totalCF, 0),
capitalDistributionCurrent = cashAvailableDistribution * isDistribution,
undistributedCash = capitalDistributionCurrent - cashAvailableDistribution,
cumUndistributedCash = -cumsum(undistributedCash),
distributionAccruedCash = cumUndistributedCash * isDistribution,
capitalDistribution = distributionAccruedCash + capitalDistributionCurrent,
capitalCF = capitalContribution + capitalDistribution
) %>%
dplyr::select(
-c(
undistributedCash,
cumUndistributedCash,
distributionAccruedCash,
capitalDistributionCurrent
)
) %>%
mutate(
daysAccrued = as.numeric((date - dplyr::lag(date))),
daysAccrued = ifelse(daysAccrued %>% is.na(), 0, daysAccrued),
cumDays = cumsum(daysAccrued),
cumContribution = cumsum(capitalContribution),
cumDistribution = cumsum(capitalDistribution),
ratioCapitalReturned = (abs(cumDistribution) / cumContribution) %>% as.numeric,
cumCF = cumsum(cashFlow),
endCash = cumContribution + cumDistribution + cumCF,
beginCash = ifelse(idPeriod == 0, 0, dplyr::lag(endCash))
) %>%
mutate_at(
.vars = c(
"cashFlow",
"workingCapital",
'capitalCF',
"totalCF",
"capitalContribution",
"capitalDistribution",
"beginCash",
"endCash",
"cumContribution",
"cumDistribution",
"cumCF"
),
currency
) %>%
dplyr::select_(
.dots = c(
"idPeriod",
"date",
'daysAccrued',
'cumDays',
"cashFlow",
"isSalePeriod",
"workingCapital",
"totalCF",
"capitalContribution",
"capitalDistribution",
'capitalCF',
'ratioCapitalReturned',
"beginCash",
"endCash",
"cumContribution",
"cumDistribution",
"cumCF"
)
)
if (!(cf_data$totalCF %>% sum) + ((cf_data$capitalContribution %>% sum) + (cf_data$capitalDistribution %>% sum)) == 0) {
stop("Cash does not balance")
}
if (remove_cumulative_cols) {
cf_data <-
cf_data %>%
dplyr::select(-dplyr::matches("cum"))
}
return(cf_data)
}
calculate_cash_flows_returns <-
function(dates = c(
"2016-09-01",
"2017-08-31",
"2018-08-31",
"2019-08-31",
"2020-08-31",
"2021-08-31",
"2022-08-31",
"2023-08-31"
),
cash_flows = c(
-4151601,
119499.036215643,
257186.036215643,
447646.036215643,
200652.036215643,
510409.036215643,
193.036215643166,
8788626.76409155
),
working_capital = 125000,
remove_cumulative_cols = T,
distribution_frequency = 'annually',
date_format = '%Y-%m-%d',
scale_to_100 = F,
return_percentage = F,
return_df = T,
return_message = T) {
cf_data <-
calculate_cash_flow_dates(
dates = dates,
cash_flows = cash_flows,
working_capital = working_capital,
distribution_frequency = distribution_frequency,
remove_cumulative_cols = remove_cumulative_cols
)
cf_return_data <-
calculate_irr_periods(
dates = cf_data$date,
cash_flows = cf_data$capitalCF,
date_format = date_format,
return_percentage = return_percentage,
return_df = return_df,
return_message = return_message
)
cf_Data
}
scale_to_pct <- function(x) {
if (x > 1) {
x <-
x / 100
}
return(x)
}
.parse_promote_structure <-
function(promote_structure = "20 over a 12") {
hit_words <-
c(" over a ", " over ", "over", "over ", "over a",
"/", " / ", " until ", " on ")
has_no_promote <-
!promote_structure %>%
str_detect(hit_words %>% paste0(collapse = "|"))
if (has_no_promote) {
stop(
"No promote structure detected\nPromote structure looks like 20 over a 12, 30 over 5x, 12 / 9"
)
}
typeHurdle <-
case_when(promote_structure %>% str_detect("x") ~ "multiple",
promote_structure %>% str_detect("until") ~ "amount",
TRUE ~ "pref")
hurdle_promote <-
promote_structure %>%
str_split(pattern = hit_words %>% paste0(collapse = "|")) %>%
future_map(parse_number) %>%
flatten_dbl()
case_when(
typeHurdle == "multiple" ~ hurdle_promote[[1]] %>% scale_to_pct()
)
if (typeHurdle %in% c('multiple', "amount")) {
hurdle_promote[[1]] <-
hurdle_promote[[1]] %>%
scale_to_pct()
} else if (typeHurdle == "pref") {
hurdle_promote <-
hurdle_promote %>%
map_dbl(scale_to_pct)
}
items <-
c("pctPromote", 'valueHurdle')
promote_df <-
tibble(typeHurdle,
item = items,
value = hurdle_promote) %>%
mutate(
item =
case_when(
typeHurdle == "pref" ~ item %>% str_replace(pattern = "valueHurdle", 'pctPref'),
typeHurdle == "multiple" ~ item %>% str_replace(pattern = "valueHurdle", 'ratioCapitalMultiple'),
TRUE ~ item %>% str_replace(pattern = "valueHurdle", 'amountFee')
)
) %>%
spread(item, value)
return(promote_df)
}
tidy_promote_structure <-
function(promote_structures = c("20 over a 12", '30 / 18', "40 over a 10x"),
return_wide = F) {
parse_promote_structure_safe <-
purrr::possibly(.parse_promote_structure, tibble())
promote_data <-
seq_along(promote_structures) %>%
future_map_dfr(function(x) {
parse_promote_structure_safe(promote_structure = promote_structures[x]) %>%
mutate(tierWaterfall = x) %>%
dplyr::select(tierWaterfall, everything())
})
if (return_wide) {
promote_data <-
promote_data %>%
gather(item, hurdle, -c(tierWaterfall)) %>%
replace_na(list(hurdle = 0)) %>%
arrange(tierWaterfall) %>%
unite(item, item, tierWaterfall, sep = '') %>%
mutate(item = item %>% factor(ordered = T, levels = item)) %>%
spread(item, hurdle)
promote_data <-
promote_data %>%
mutate_at(.vars =
promote_data %>% dplyr::select(dplyr::matches("^pct[A-Z]|ratio[A-Z]")) %>% names,
funs(. %>% as.numeric)) %>%
mutate_at(.vars =
promote_data %>% dplyr::select(dplyr::matches("^pct[A-Z]")) %>% names,
funs(. %>% percent))
} else {
promote_data <-
promote_data %>%
mutate(nameTier = promote_structures) %>%
dplyr::select(tierWaterfall, nameTier, everything())
promote_data <-
promote_data %>%
mutate_at(.vars =
promote_data %>% dplyr::select(dplyr::matches("^pct[A-Z]")) %>% names,
funs(. %>% percent)) %>%
dplyr::select(
tierWaterfall,
nameTier,
typeHurdle,
dplyr::matches("pctPref|ratioCapitalMultiple|amountFee"),
pctPromote,
everything()
)
}
return(promote_data)
}
calculate_days_accrued_pref <-
function(pct_pref = .1,
is_actual_360 = TRUE,
days = 31,
equity_bb = 1700000.00,
pref_accrued_bb = 0) {
if (is_actual_360) {
accrual_days <-
360
} else {
accrual_days <-
365
}
calc_basis <-
(equity_bb + pref_accrued_bb) %>% currency(digits = 2)
accrued_pref <-
((pct_pref / accrual_days) * days * calc_basis)
return(accrued_pref)
}
.get_pct_to_promote <-
function(promote_df, tier_waterfall = 2) {
if (tier_waterfall %in% promote_df$tierWaterfall) {
to_promote <-
promote_df %>%
dplyr::filter(tierWaterfall == tier_waterfall) %>%
.$pctPromote
} else {
to_promote <-
0
}
return(to_promote)
}
.waterfall_tier_df <-
function(tiers = 1:5,
return_wide = F) {
waterfall_df <-
tibble(
tierWaterfall = 1,
bbAccruedPref = 0,
accruedPref = 0,
distributionPriorPref = 0,
toAccruedPref = 0,
ebAccruedPref = 0,
bbCapitalMultiple = 0,
capitalMultipleDraw = 0,
toEquity = 0,
distributionPriorMultiple = 0,
toCapitalMultiple = 0,
ebCapitalMultiple = 0,
bbFee = 0,
feeDraw = 0,
distributionPriorFee = 0,
toFee = 0,
ebFee = 0,
toPromote = 0,
toCapital = 0
)
if (tiers %>% length > 1) {
other_tiers <-
tiers[tiers > 1] %>%
future_map_dfr(function(x) {
tibble(
tierWaterfall = rep(x),
bbAccruedPref = 0,
accruedPref = 0,
distributionPriorPref = 0,
toAccruedPref = 0,
ebAccruedPref = 0,
bbCapitalMultiple = 0,
capitalMultipleDraw = 0,
toEquity = 0,
distributionPriorMultiple = 0,
toCapitalMultiple = 0,
ebCapitalMultiple = 0,
bbFee = 0,
feeDraw = 0,
distributionPriorFee = 0,
toFee = 0,
ebFee = 0,
toPromote = 0,
toCapital = 0
)
})
waterfall_df <-
waterfall_df %>%
bind_rows(other_tiers)
}
convert_cols <- waterfall_df %>% select_if(is.numeric) %>% select(-dplyr::matches("idPeriod|tier")) %>% names()
waterfall_df <-
waterfall_df %>%
mutate_at(convert_cols, currency)
if (return_wide) {
waterfall_df <-
waterfall_df %>%
gather(item, amount, -tierWaterfall, convert = F) %>%
arrange(tierWaterfall, item) %>%
unite(item, item, tierWaterfall, sep = '') %>%
suppressWarnings()
col_order <-
waterfall_df$item
waterfall_df <-
waterfall_df %>%
spread(item, amount) %>%
dplyr::select(one_of(col_order))
}
return(waterfall_df)
}
.get_initial_equity_df <-
function(equity_bb = 0,
to_equity = 0,
period = 0,
equity_draw = 0) {
equityBB <-
equity_bb
toEquity <-
to_equity
equityDraw <-
equity_draw
equityEB <-
equityBB + equityDraw + toEquity
equity_df <-
tibble(idPeriod = period,
equityBB,
equityDraw,
toEquity,
equityEB) %>%
mutate_at(
.vars = c('equityBB', 'equityDraw',
'toEquity', 'equityEB'),
.funs = currency
)
return(equity_df)
}
calculate_cash_flow_waterfall <-
function(dates =
c("2015-03-11", "2015-11-20", "2016-10-15"),
cash_flows = c(-100000, -200000, 698906.76849),
working_capital = 0,
promote_structure = c("20 / 12", "30 / 18"),
distribution_frequency = NA,
is_actual_360 = TRUE,
widen_promote_structure = FALSE,
bind_to_cf = FALSE,
remove_zero_cols = TRUE,
widen_waterfall = FALSE) {
options(scipen = 999999)
if (class(dates) != "Date") {
dates <-
readr::parse_date(dates)
}
cf_data <-
calculate_cash_flow_dates(
dates = dates,
cash_flows = cash_flows,
remove_cumulative_cols = T,
working_capital = working_capital,
distribution_frequency = distribution_frequency
)
waterfall_data <-
cf_data %>%
dplyr::select(idPeriod:daysAccrued,
capitalContribution,
capitalDistribution,
capitalCF) %>%
mutate(cashDistributionAvailable = -pmin(0, capitalCF) %>% currency())
promote_df <-
tidy_promote_structure(promote_structures = promote_structure,
return_wide = widen_promote_structure)
waterfall_periods <-
waterfall_data$idPeriod
tiers <-
promote_df$tierWaterfall
waterfall_df <-
tibble()
for (x in seq_along(waterfall_periods)) {
period <-
waterfall_periods[x]
period_data <-
waterfall_data %>%
dplyr::filter(idPeriod == period)
days <-
period_data$daysAccrued
equityDraw <-
period_data$capitalContribution
periodCAD <-
period_data$cashDistributionAvailable %>% as.numeric() %>%digits(2) %>% currency
if (period == 0) {
equity_df <-
.get_initial_equity_df(
equity_bb = 0,
to_equity = 0,
equity_draw = equityDraw,
period = 0
)
waterfall_df <-
.waterfall_tier_df(tiers = tiers) %>%
mutate(idPeriod = period) %>%
dplyr::select(idPeriod, everything())
}
if (period > 0) {
equityBB <-
equity_df %>% dplyr::filter(idPeriod == period - 1) %>% .$equityEB
for (tier in tiers) {
typeHurdle <-
promote_df %>% dplyr::filter(tierWaterfall == tier) %>% .$typeHurdle
bbAccruedPref <-
max(
0,
waterfall_df %>% dplyr::filter(idPeriod == period - 1 &
tierWaterfall == tier) %>% .$ebAccruedPref
)
bbCapitalMultiple <-
max(
0,
waterfall_df %>% dplyr::filter(idPeriod == period - 1, tierWaterfall == tier) %>% .$ebCapitalMultiple
)
tierPromote <-
promote_df %>% dplyr::filter(tierWaterfall == tier) %>% .$pctPromote
if (tier == max(tiers)) {
is_max_tier <-
T
} else {
is_max_tier <-
F
}
if (typeHurdle == 'pref') {
tierPref <-
promote_df %>% dplyr::filter(tierWaterfall == tier) %>% .$pctPref
accruedPref <-
calculate_days_accrued_pref(
pct_pref = tierPref,
is_actual_360 = is_actual_360,
days = days,
equity_bb = equityBB,
pref_accrued_bb = bbAccruedPref
)
capitalMultipleDraw <-
0
distributionPriorMultiple <-
0
toCapitalMultiple <-
0
ebCapitalMultiple <-
0
if (tier == 1) {
toAccruedPref <-
-min(periodCAD, (accruedPref + bbAccruedPref)) %>% as.numeric() %>%digits(2)
ebAccruedPref <-
(bbAccruedPref + accruedPref + toAccruedPref) %>% as.numeric() %>%digits(2)
cash_to_equity <-
max(0, (periodCAD + toAccruedPref)) %>% as.numeric() %>%digits(2)
toEquity <-
-min(cash_to_equity, (equityBB + equityDraw)) %>% as.numeric() %>%digits(2)
equityEB <-
(equityBB + equityDraw + toEquity) %>% as.numeric() %>%digits(2)
to_promote_tier <-
max(0, (cash_to_equity + toEquity)) %>% as.numeric() %>%digits(2)
distributionPriorPref <-
0
if (is_max_tier) {
toPromote <-
-to_promote_tier * tierPromote
toCapital <-
-to_promote_tier * (1 - tierPromote)
}
if (is_max_tier == F) {
typeNextTier <-
promote_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$typeHurdle
if (typeNextTier == 'pref') {
nextPref <-
promote_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$pctPref
bbAccruedPrefNext <-
waterfall_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$bbAccruedPref
prefAccruedNext <-
calculate_days_accrued_pref(
pct_pref = nextPref,
is_actual_360 = is_actual_360,
days = days,
equity_bb = equityBB,
pref_accrued_bb = bbAccruedPrefNext
)
cash_for_promote <-
-min(to_promote_tier, max(
0,
(bbAccruedPref + prefAccruedNext + toAccruedPref) / (1 - tierPromote)
))
}
if (typeNextTier == 'multiple') {
nextMultiple <-
promote_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$ratioCapitalMultiple
bbCapitalMultipleNext <-
waterfall_df %>% dplyr::filter(idPeriod == period - 1, tierWaterfall == tier + 1) %>% .$ebCapitalMultiple
capitalMultipleDrawNext <-
(equity_df %>% dplyr::filter(idPeriod == period - 1) %>% .$equityDraw) * nextMultiple
cash_for_promote <-
-min(to_promote_tier, max(
0,
(
bbCapitalMultipleNext + capitalMultipleDrawNext + toAccruedPref
) / (1 - tierPromote)
))
}
toCapital <-
cash_for_promote * (1 - tierPromote)
toPromote <-
cash_for_promote * (tierPromote)
}
}
if (tier > 1) {
priorLevelDistribution <-
waterfall_df %>%
dplyr::filter(idPeriod == period &
tierWaterfall < tier) %>% dplyr::select(toAccruedPref,
toPromote,
toCapital,
toCapitalMultiple) %>% gather(item, value) %>%
.$value %>% sum
equityDistribution <-
equity_df %>% dplyr::filter(idPeriod == period) %>% dplyr::select(toEquity) %>% gather(item, value) %>% .$value %>% sum
remainingCash <-
periodCAD + priorLevelDistribution + equityDistribution
distributionPriorMultiple <-
waterfall_df %>% dplyr::filter(idPeriod == period &
tierWaterfall == (tier - 1)) %>% dplyr::select(distributionPriorMultiple) %>% gather(item, value) %>% .$value %>% sum
distributionPriorPref <-
waterfall_df %>% dplyr::filter(idPeriod == period &
tierWaterfall == (tier - 1)) %>% dplyr::select(distributionPriorPref, toAccruedPref) %>% gather(item, value) %>% .$value %>% sum
toAccruedPref <-
-max(0, min(
remainingCash,
(
bbAccruedPref + accruedPref + distributionPriorPref + distributionPriorMultiple
)
))
to_promote_tier <-
remainingCash + toAccruedPref
ebAccruedPref <-
bbAccruedPref + accruedPref + distributionPriorPref + distributionPriorMultiple + toAccruedPref
if (is_max_tier) {
toPromote <-
-to_promote_tier * tierPromote
toCapital <-
-to_promote_tier * (1 - tierPromote)
}
if (is_max_tier == F) {
typeNextTier <-
promote_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$typeHurdle
if (typeNextTier == 'pref') {
nextPref <-
promote_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$pctPref
bbAccruedPrefNext <-
waterfall_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$bbAccruedPref
prefAccruedNext <-
calculate_days_accrued_pref(
pct_pref = nextPref,
is_actual_360 = is_actual_360,
days = days,
equity_bb = equityBB,
pref_accrued_bb = bbAccruedPrefNext
)
cash_for_promote <-
-min(to_promote_tier, max(
0,
(bbAccruedPref + prefAccruedNext + toAccruedPref) / (1 - tierPromote)
))
}
if (typeNextTier == 'multiple') {
nextMultiple <-
promote_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$ratioCapitalMultiple
bbCapitalMultipleNext <-
waterfall_df %>% dplyr::filter(idPeriod == period - 1, tierWaterfall == tier + 1) %>% .$ebCapitalMultiple
capitalMultipleDrawNext <-
(equity_df %>% dplyr::filter(idPeriod == period - 1) %>% .$equityDraw) * nextMultiple
cash_for_promote <-
-min(to_promote_tier, max(
0,
(
bbCapitalMultipleNext + capitalMultipleDrawNext + toAccruedPref + distributionPriorPref + toEquity
) / (1 - tierPromote)
))
}
toCapital <-
cash_for_promote * (1 - tierPromote)
toPromote <-
cash_for_promote * (tierPromote)
}
}
}
if (typeHurdle == 'multiple') {
ratioCapitalMultiple <-
promote_df %>% dplyr::filter(tierWaterfall == tier) %>% .$ratioCapitalMultiple
if (tier == 1) {
accruedPref <-
0
toAccruedPref <-
0
ebAccruedPref <-
0
cash_to_equity <-
max(0, (periodCAD + toAccruedPref)) %>% as.numeric() %>%digits(2) %>% currency
toEquity <-
-min(cash_to_equity, (equityBB + equityDraw)) %>% as.numeric() %>%digits(2) %>% currency
equityEB <-
(equityBB + equityDraw + toEquity) %>% as.numeric() %>%digits(2) %>% currency
cash_to_multiple <-
max(0, (cash_to_equity + toEquity)) %>% as.numeric() %>%digits(2) %>% currency
capitalMultipleDraw <-
(equity_df %>% dplyr::filter(idPeriod == period - 1) %>% .$equityDraw) * ratioCapitalMultiple
toCapitalMultiple <-
-min(cash_to_multiple,
(bbCapitalMultiple + capitalMultipleDraw + toEquity)) %>% as.numeric() %>%digits(2) %>%
currency
ebCapitalMultiple <-
bbCapitalMultiple + capitalMultipleDraw + toEquity + toCapitalMultiple
to_promote_tier <-
max(0, (cash_to_multiple + toCapitalMultiple)) %>% as.numeric() %>%digits(2) %>%
currency
distributionPriorPref <-
0
distributionPriorMultiple <-
0
if (is_max_tier) {
toPromote <-
-to_promote_tier * tierPromote
toCapital <-
-to_promote_tier * (1 - tierPromote)
}
if (is_max_tier == F) {
nextMultiple <-
promote_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$ratioCapitalMultiple
bbCapitalMultipleNext <-
waterfall_df %>% dplyr::filter(idPeriod == period - 1, tierWaterfall == tier + 1) %>% .$ebCapitalMultiple
capitalMultipleDrawNext <-
(equity_df %>% dplyr::filter(idPeriod == period - 1) %>% .$equityDraw) * nextMultiple
cash_for_promote <-
-min(to_promote_tier, max(
0,
(
bbCapitalMultipleNext + capitalMultipleDrawNext + toCapitalMultiple + toEquity
) / (1 - tierPromote)
))
toCapital <-
cash_for_promote * (1 - tierPromote)
toPromote <-
cash_for_promote * (tierPromote)
}
}
if (tier > 1) {
priorLevelDistribution <-
waterfall_df %>%
dplyr::filter(idPeriod == period &
tierWaterfall < tier) %>%
dplyr::select(tierWaterfall,
toAccruedPref,
toPromote,
toCapital,
toCapitalMultiple) %>%
gather(item, value, -tierWaterfall) %>% .$value %>% sum %>%
currency
equityDistribution <-
equity_df %>% dplyr::filter(idPeriod == period) %>% dplyr::select(toEquity) %>% gather(item, value) %>% .$value %>% sum %>% currency
remainingCash <-
periodCAD + priorLevelDistribution + equityDistribution
accruedPref <-
0
toAccruedPref <-
0
ebAccruedPref <-
bbAccruedPref + accruedPref + toAccruedPref
capitalMultipleDraw <-
(equity_df %>% dplyr::filter(idPeriod == period - 1) %>% .$equityDraw) * ratioCapitalMultiple %>%
currency()
distributionPriorMultiple <-
waterfall_df %>%
dplyr::filter(idPeriod == period &
tierWaterfall <= (tier - 1)) %>%
dplyr::select(toCapitalMultiple, toCapital) %>% gather(item, value) %>%
.$value %>%
sum %>%
currency
distributionPriorPref <-
waterfall_df %>% dplyr::filter(idPeriod == period &
tierWaterfall <= (tier - 1)) %>% dplyr::select(toAccruedPref) %>% gather(item, value) %>% .$value %>% sum %>%
currency
priorEquity <-
waterfall_df %>% dplyr::filter(idPeriod == period &
tierWaterfall == (tier - 1)) %>% dplyr::select(toEquity) %>% gather(item, value) %>% .$value %>% sum %>%
currency()
toCapitalMultiple <-
-max(0,
min(
remainingCash,
(
bbCapitalMultiple + capitalMultipleDraw + distributionPriorMultiple + distributionPriorPref + priorEquity
)
)) %>%
currency()
to_promote_tier <-
remainingCash + toCapitalMultiple
ebCapitalMultiple <-
bbCapitalMultiple + capitalMultipleDraw + distributionPriorMultiple + distributionPriorPref + priorEquity + toCapitalMultiple
if (is_max_tier) {
toPromote <-
-to_promote_tier * tierPromote
toCapital <-
-to_promote_tier * (1 - tierPromote)
}
if (is_max_tier == F) {
nextMultiple <-
promote_df %>%
dplyr::filter(tierWaterfall == tier + 1) %>% .$ratioCapitalMultiple
bbCapitalMultipleNext <-
waterfall_df %>% dplyr::filter(idPeriod == period - 1, tierWaterfall == tier + 1) %>% .$ebCapitalMultiple %>%
currency()
capitalMultipleDrawNext <-
(equity_df %>% dplyr::filter(idPeriod == period - 1) %>% .$equityDraw) * nextMultiple %>%
currency
cash_for_promote <-
-min(to_promote_tier, max(
0,
(
bbCapitalMultipleNext + capitalMultipleDrawNext + toCapitalMultiple + distributionPriorMultiple + distributionPriorPref + equityDistribution
) / (1 - tierPromote)
))
toCapital <-
cash_for_promote * (1 - tierPromote)
toPromote <-
cash_for_promote * (tierPromote)
}
}
}
period_waterfall <-
tibble(
idPeriod = period,
tierWaterfall = tier,
bbAccruedPref,
accruedPref,
distributionPriorPref = distributionPriorPref,
toAccruedPref,
ebAccruedPref,
bbCapitalMultiple,
capitalMultipleDraw,
distributionPriorMultiple,
toEquity,
toCapitalMultiple,
ebCapitalMultiple,
toPromote,
toCapital
) %>%
mutate_if(is.numeric, as.numeric)
waterfall_df <-
waterfall_df %>%
mutate_if(is.numeric, as.numeric) %>%
bind_rows(period_waterfall) %>%
distinct()
period_equity <-
tibble(idPeriod = period,
equityBB,
equityDraw,
toEquity,
equityEB)
equity_df <-
equity_df %>%
bind_rows(period_equity) %>%
distinct()
}
}
}
if ('toEquity' %in% names(waterfall_df)) {
waterfall_df <-
waterfall_df %>% dplyr::select(-toEquity)
}
if (remove_zero_cols) {
waterfall_df <-
waterfall_df %>% dplyr::select(which(colSums(abs(.) != 0) > 0))
}
waterfall_df <-
waterfall_df %>%
mutate_at(waterfall_df %>% dplyr::select(-c(idPeriod, tierWaterfall)) %>% names,
.funs = currency)
equity_df <-
equity_df %>%
mutate_at(equity_df %>% dplyr::select(-c(idPeriod)) %>% names,
.funs = currency)
equityDistributions <-
equity_df$toEquity %>% sum
levelDistributions <-
waterfall_df %>% dplyr::select(dplyr::matches("to")) %>% gather(item, value) %>% .$value %>% sum %>% currency %>% suppressWarnings()
cash_check <-
((cf_data$capitalDistribution %>% sum %>% abs) + (equityDistributions + levelDistributions)
) %>% as.integer()
if (!cash_check == 0) {
stop("Waterfall does not tie to distributable by\n" %>%
paste0(cash_check %>% currency))
}
if (widen_waterfall) {
col_order <-
waterfall_df %>%
gather(item, value, -c(idPeriod, tierWaterfall)) %>%
arrange(idPeriod, tierWaterfall) %>%
unite(item, item, tierWaterfall, sep = '') %>%
.$item %>%
suppressWarnings()
waterfall_df <-
waterfall_df %>%
gather(item, value, -c(idPeriod, tierWaterfall)) %>%
arrange(idPeriod, tierWaterfall) %>%
unite(item, item, tierWaterfall, sep = '') %>%
spread(item, value) %>%
mutate_at(col_order, currency) %>%
dplyr::select(one_of(c('idPeriod', col_order))) %>%
suppressWarnings()
waterfall_df <-
equity_df %>%
left_join(waterfall_df) %>%
suppressMessages()
if (bind_to_cf) {
waterfall_df <-
cf_data %>%
left_join(waterfall_df) %>%
suppressMessages()
}
}
if (widen_waterfall == F) {
waterfall_df <-
waterfall_df %>%
bind_rows(equity_df %>% mutate(tierWaterfall = 0)) %>%
arrange(idPeriod, tierWaterfall) %>%
mutate(tierWaterfall = tierWaterfall + 1)
numeric_cols <-
waterfall_df %>% dplyr::select(-c(idPeriod, tierWaterfall)) %>% names
waterfall_df <-
waterfall_df %>%
mutate_if(is.numeric, as.numeric) %>%
mutate_at(
.vars = numeric_cols,
.funs = function(x)
if_else(x %>% is.na, 0, x)
)
currency_vars <- waterfall_df %>%
select_if(is.numeric) %>%
select(-c(idPeriod, tierWaterfall)) %>%
names()
waterfall_df <-
waterfall_df %>%
mutate_at(currency_vars, formattable::currency)
}
waterfall_df <-
waterfall_df %>%
left_join(waterfall_data %>% dplyr::select(idPeriod, date)) %>%
dplyr::select(idPeriod, date, everything()) %>%
suppressMessages(
)
waterfall_df
}
calculate_cash_flow_waterfall_partnership <-
function(dates =
c("2016-09-01",
"2017-08-31"),
cash_flows = c(-1500000,
105000000),
working_capital = 200000,
promote_structure = c("20 over 12", "30 over 20", "50 over 3.5x", "100 over 10x"),
assign_to_environment = TRUE,
general_partner_pct = .05,
gp_promote_share = 1,
unnest_data = FALSE,
exclude_partnership_total = FALSE,
distribution_frequency = NA,
is_actual_360 = TRUE,
widen_promote_structure = FALSE,
bind_to_cf = FALSE,
remove_zero_cols = TRUE,
widen_waterfall = FALSE) {
options(scipen = 9999999)
pct_gp <-
general_partner_pct %>% scale_to_pct()
pct_lp <-
1 - pct_gp
share_gp_promote <-
gp_promote_share
share_lp_promote_share <-
1 - gp_promote_share
promote_name_df <-
tibble(tierWaterfall = 1,
nameTier = "Return of Equity") %>%
bind_rows(
tidy_promote_structure(promote_structures = promote_structure,
return_wide = F) %>%
mutate(tierWaterfall = tierWaterfall + 1) %>%
dplyr::select(tierWaterfall, nameTier)
)
waterfall_data <-
calculate_cash_flow_waterfall(
dates = dates,
cash_flows = cash_flows,
working_capital = working_capital,
is_actual_360 = is_actual_360,
promote_structure = promote_structure,
bind_to_cf = F,
widen_promote_structure = F
) %>%
dplyr::select(idPeriod:tierWaterfall,
equityDraw, toEquity, everything())
entity_waterfall <-
waterfall_data %>%
dplyr::select(idPeriod,
date,
tierWaterfall,
dplyr::matches("equityDraw"),
dplyr::matches("to")) %>%
gather(item, toCF, -c(idPeriod, date, tierWaterfall)) %>%
dplyr::filter(!toCF == 0) %>%
mutate(
toGP = -ifelse(item == 'toPromote', toCF * share_gp_promote, toCF * pct_gp),
toLP = -ifelse(item == 'toPromote',
toCF * share_lp_promote_share,
toCF * pct_lp)
) %>%
mutate_at(.vars = c('toCF', 'toGP', 'toLP'),
.funs = currency) %>%
arrange(idPeriod, tierWaterfall) %>%
left_join(promote_name_df, by = "tierWaterfall") %>%
dplyr::select(idPeriod:tierWaterfall, nameTier, everything())
cash_check <-
((entity_waterfall$toCF %>% sum()) + (entity_waterfall$toGP %>% sum()) + (entity_waterfall$toLP %>% sum())
) %>% as.integer()
if (!cash_check == 0) {
stop("Cash does not tie")
}
entity_cf <-
entity_waterfall %>%
dplyr::select(date, toCF) %>%
group_by(date) %>%
summarise(totalCF = sum(as.numeric(toCF))) %>%
ungroup() %>%
mutate(totalCF = totalCF %>% currency())
gp_cf <-
entity_waterfall %>%
dplyr::select(date, toGP) %>%
group_by(date) %>%
summarise(totalCF = sum(toGP)) %>%
ungroup()
lp_cf <-
entity_waterfall %>%
dplyr::select(date, toLP) %>%
group_by(date) %>%
summarise(totalCF = sum(toLP))
"Partnership returns:" %>% message()
total_return_df <-
calculate_irr_periods(
dates = entity_cf$date,
cash_flows = entity_cf$totalCF,
return_percentage = T,
return_df = T
) %>%
mutate(typeEntity = 'Partnership') %>%
dplyr::select(typeEntity, everything()) %>%
suppressWarnings()
"General Partner returns:" %>% message()
gp_return_df <-
calculate_irr_periods(
dates = gp_cf$date,
cash_flows = -gp_cf$totalCF,
return_percentage = T,
return_df = T
) %>%
mutate(typeEntity = 'General Partner') %>%
dplyr::select(typeEntity, everything())
"Limited Partner returns:" %>% message()
lp_return_df <-
calculate_irr_periods(
dates = lp_cf$date,
cash_flows = -lp_cf$totalCF,
return_percentage = T,
return_df = T
) %>%
mutate(typeEntity = 'Limited Partner') %>%
dplyr::select(typeEntity, everything())
partnership_return_summary <-
gp_return_df %>%
bind_rows(list(lp_return_df, total_return_df))
if (partnership_return_summary %>% tibble::has_name("value")) {
partnership_return_summary <-
partnership_return_summary %>%
spread(metric, value)
}
partnership_return_summary <-
partnership_return_summary %>%
mutate_at(.vars = c('pctIRR'),
.funs = percent) %>%
mutate_at(
.vars = c(
"equityContributions",
"equityDistributions",
"amountProfit"
),
.funs = currency
)
if (exclude_partnership_total) {
partnership_return_summary <-
partnership_return_summary %>%
dplyr::filter(!typeEntity %in% 'Partnership')
}
data <-
tibble(
nameTable =
c(
'Cash Flow Waterfall',
'Entity Waterfall',
'Partnership Return Summary'
),
dataTable =
list(
waterfall_data,
entity_waterfall,
partnership_return_summary
)
)
if (assign_to_environment) {
data <-
data %>%
left_join(tibble(
nameTable = c(
"Cash Flow Waterfall",
"Entity Waterfall",
"Partnership Return Summary"
),
idDF = c(
'cashflowWaterfall',
'entityWaterfall',
'partnershipReturns'
)
)) %>%
suppressMessages()
1:nrow(data) %>%
future_map(function(x) {
table_data <-
data$dataTable[[x]]
df_name <-
data$idDF[[x]]
assign(x = df_name, eval(table_data), envir = .GlobalEnv)
})
data <-
data %>%
dplyr::select(-idDF)
}
if (unnest_data) {
data <-
data %>%
unnest()
}
data
} |
structure(list(
url = "http://httpbin.org/status/204", status_code = 204L,
headers = structure(list(
`content-length` = "0", connection = "keep-alive",
server = "meinheld/0.6.1", date = "Sat, 24 Feb 2018 00:22:11 GMT",
`content-type` = "text/html; charset=utf-8", `access-control-allow-origin` = "*",
`access-control-allow-credentials` = "true", `x-powered-by` = "Flask",
`x-processed-time` = "0", via = "1.1 vegur"
), .Names = c(
"content-length",
"connection", "server", "date", "content-type", "access-control-allow-origin",
"access-control-allow-credentials", "x-powered-by", "x-processed-time",
"via"
), class = c("insensitive", "list")), all_headers = list(
structure(list(status = 204L, version = "HTTP/1.1", headers = structure(list(
`content-length` = "0", connection = "keep-alive",
server = "meinheld/0.6.1", date = "Sat, 24 Feb 2018 00:22:11 GMT",
`content-type` = "text/html; charset=utf-8", `access-control-allow-origin` = "*",
`access-control-allow-credentials` = "true", `x-powered-by` = "Flask",
`x-processed-time` = "0", via = "1.1 vegur"
), .Names = c(
"content-length",
"connection", "server", "date", "content-type", "access-control-allow-origin",
"access-control-allow-credentials", "x-powered-by", "x-processed-time",
"via"
), class = c("insensitive", "list"))), .Names = c(
"status",
"version", "headers"
))
), cookies = structure(list(
domain = logical(0),
flag = logical(0), path = logical(0), secure = logical(0),
expiration = structure(numeric(0), class = c(
"POSIXct",
"POSIXt"
)), name = logical(0), value = logical(0)
), .Names = c(
"domain",
"flag", "path", "secure", "expiration", "name", "value"
), row.names = integer(0), class = "data.frame"),
content = charToRaw(""), date = structure(1519431731, class = c(
"POSIXct",
"POSIXt"
), tzone = "GMT"), times = structure(c(
0, 4.5e-05,
4.8e-05, 0.000105, 0.100235, 0.100262
), .Names = c(
"redirect",
"namelookup", "connect", "pretransfer", "starttransfer",
"total"
))
), .Names = c(
"url", "status_code", "headers", "all_headers",
"cookies", "content", "date", "times"
), class = "response") |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.