114 lines
3.6 KiB
Markdown
114 lines
3.6 KiB
Markdown
## Build and install.
|
|
To build the package the `devtools` package is used. This also provides `roxygen2` which is used for documentation and authomatic creaton of the `NAMESPACE` file.
|
|
```R
|
|
setwd("./CVE_R") # Set path to the package root.
|
|
library(devtools) # Load required `devtools` package.
|
|
document() # Create `.Rd` files and write `NAMESPACE`.
|
|
```
|
|
Next the package needs to be build, therefore (if pure `R` package, aka. `C/C++`, `Fortran`, ... code) just do the following.
|
|
```bash
|
|
R CMD build CVE_R
|
|
R CMD INSTALL CVE_0.1.tar.gz
|
|
```
|
|
Then we are ready for using the package.
|
|
```R
|
|
library(CVE)
|
|
help(package = "CVE")
|
|
```
|
|
## Build and install from within `R`.
|
|
An alternative approach is the following.
|
|
```R
|
|
setwd('./CVE_R')
|
|
getwd()
|
|
|
|
library(devtools)
|
|
document()
|
|
# No vignettes to build but "inst/doc/" is required!
|
|
(path <- build(vignettes = FALSE))
|
|
install.packages(path, repos = NULL, type = "source")
|
|
```
|
|
**Note: I only recommend this approach during development.**
|
|
|
|
## Reading log files.
|
|
The runtime tests (upcomming further tests) are creating log files saved in `tmp/`. These log files are `CSV` files (actualy `TSV`) with a header storing the test results. Depending on the test the files may contain differnt data. As an example we use the runtime test logs which store in each line the `dataset`, the used `method` as well as the `error` (actual error of estimated `B` against real `B`) and the `time`. For reading and analysing the data see the following example.
|
|
```R
|
|
# Load log as `data.frame`
|
|
test0 <- read.csv('tmp/test0.log', sep = '\t')
|
|
# Create a error boxplot grouped by dataset.
|
|
boxplot(error ~ dataset, test0)
|
|
```
|
|
|
|
## Environments and variable lookup.
|
|
In the following a view simple examples of how `R` searches for variables.
|
|
In addition we manipulate funciton closures to alter the search path in variable lookup and outer scope variable manipulation.
|
|
```R
|
|
droids <- "These aren't the droids you're looking for."
|
|
|
|
search <- function() {
|
|
print(droids)
|
|
}
|
|
|
|
trooper.seeks <- function() {
|
|
droids <- c("R2-D2", "C-3PO")
|
|
search()
|
|
}
|
|
|
|
jedi.seeks <- function() {
|
|
droids <- c("R2-D2", "C-3PO")
|
|
environment(search) <- environment()
|
|
search()
|
|
}
|
|
|
|
trooper.seeks()
|
|
jedi.seeks()
|
|
```
|
|
|
|
The next example ilustrates how to write (without local copies) to variables outside the functions local environment.
|
|
```R
|
|
counting <- function() {
|
|
count <<- count + 1 # Note the `<<-` assignment.
|
|
}
|
|
|
|
(function() {
|
|
environment(counting) <- environment()
|
|
count <- 0
|
|
|
|
for (i in 1:10) {
|
|
counting()
|
|
}
|
|
|
|
return(count)
|
|
})()
|
|
|
|
(function () {
|
|
closure <- new.env()
|
|
environment(counting) <- closure
|
|
assign("count", 0, envir = closure)
|
|
|
|
for (i in 1:10) {
|
|
counting()
|
|
}
|
|
|
|
return(closure$count)
|
|
})()
|
|
```
|
|
|
|
Another example for the usage of `do.call` where the evaluation of parameters is illustated (example taken (and altered) from `?do.call`).
|
|
```R
|
|
## examples of where objects will be found.
|
|
A <- "A.Global"
|
|
f <- function(x) print(paste("f.new", x))
|
|
env <- new.env()
|
|
assign("A", "A.new", envir = env)
|
|
assign("f", f, envir = env)
|
|
f <- function(x) print(paste("f.Global", x))
|
|
f(A) # f.Global A.Global
|
|
do.call("f", list(A)) # f.Global A.Global
|
|
do.call("f", list(A), envir = env) # f.new A.Global
|
|
do.call(f, list(A), envir = env) # f.Global A.Global
|
|
do.call("f", list(quote(A)), envir = env) # f.new A.new
|
|
do.call(f, list(quote(A)), envir = env) # f.Global A.new
|
|
do.call("f", list(as.name("A")), envir = env) # f.new A.new
|
|
do.call("f", list(as.name("A")), envir = env) # f.new A.new
|
|
```
|