| Title: | General Utility Functions Developed at KWB |
|---|---|
| Description: | This package contains some small helper functions that aim at improving the quality of code developed at Kompetenzzentrum Wasser gGmbH (KWB). |
| Authors: | Hauke Sonnenberg [aut, cre]  ,
Michael Rustler [ctb] ,
Kompetenzzentrum Wasser Berlin gGmbH (KWB) [cph] |
| Maintainer: | Hauke Sonnenberg <[email protected]> |
| License: | MIT + file LICENSE |
| Version: | 0.15.0 |
| Built: | 2024-11-01 11:16:06 UTC |
| Source: | https://github.com/KWB-R/kwb.utils |
Write Log Message to Console
.log(...).log(...)
... |
parts of the message that will be passed to |
Write Log Message and New Line Character to Console
.logline(...).logline(...)
... |
parts of the message that will be passed to |
Write "ok" and New Line Character to Console
.logok(dbg = TRUE).logok(dbg = TRUE)
dbg |
logical to switch logging on ( |
Write Log Message to Console if in Debugging Mode
.logstart(dbg = TRUE, ...).logstart(dbg = TRUE, ...)
dbg |
logical to switch logging on ( |
... |
parts of the message that will be passed to |
This is a copy of tools:::.OStype. It is redefined here so that it can be used within this package. R CMD build would complain if I used tools:::.OStype!
.OStype().OStype()
Extend the class attribute by a given class name
addClass(x, className, first = TRUE, dbg = FALSE)addClass(x, className, first = TRUE, dbg = FALSE)
x |
R object |
className |
name of the class to be added to |
first |
if |
dbg |
if |
x with the class attributed extended by
className (only if x did not yet inherit from
className)
add row to data frame and give a row name at the same time
addRowWithName(x, y, row.name)addRowWithName(x, y, row.name)
x |
data frame to which row is to be appended |
y |
data frame containing the row to be appended (exacly one row expected) |
row.name |
name of row to be given in result data frame |
x with row of y (named row.name) appended to it
Add Suffix to Column Names
addSuffixToColumns(data, suffix, except = NULL)addSuffixToColumns(data, suffix, except = NULL)
data |
data frame |
suffix |
suffix to be added to each column name except the columns given
in |
except |
names of columns to which no suffix is to be given |
data with renamed columns
d1 <- data.frame(id = 1, a = 2, b = 3) d2 <- data.frame(id = 1, c = 2, d = 3) # Using merge the origin of the column gets lost merge(d1, d2) # Add a suffix before merging merge( addSuffixToColumns(d1, ".first", except = "id"), addSuffixToColumns(d2, ".second", except = "id"), by = "id" )d1 <- data.frame(id = 1, a = 2, b = 3) d2 <- data.frame(id = 1, c = 2, d = 3) # Using merge the origin of the column gets lost merge(d1, d2) # Add a suffix before merging merge( addSuffixToColumns(d1, ".first", except = "id"), addSuffixToColumns(d2, ".second", except = "id"), by = "id" )
are all elements in x the same?
allAreEqual(x, method = 1)allAreEqual(x, method = 1)
x |
vector of elements to be compared |
method |
Select one of two methods. 1: check if the length of unique elements is equal to one, 2: check if all elements are equal to the first element. |
TRUE if all elements in x are equal to each other,
otherwise FALSE
Are all list elements identical to each other?
allAreIdentical(x)allAreIdentical(x)
x |
a list |
TRUE if all elements in x are identical, otherwise
FALSE
Compare numerical vectors accepting a tolerance
almostEqual(x, y, tolerance = 1e-12)almostEqual(x, y, tolerance = 1e-12)
x |
vector of numerical |
y |
vector of numerical |
tolerance |
tolerance, i.e. accepted difference between values in
|
vector of logical
Append Suffix to (Selected) Character Values
appendSuffix(values, suffix, valuesToOmit = NULL)appendSuffix(values, suffix, valuesToOmit = NULL)
values |
vector of character values to which suffix is to be appended |
suffix |
(character) suffix to be pasted to values that are not in valuesToOmit |
valuesToOmit |
vector of values in values to which no suffix is to be appended |
values with suffix appended to those values that are not in valuesToOmit
values <- c("a", "b", "c") # Append ".1" to all values appendSuffix(values, ".1") # Append ".1" to all values but "c" appendSuffix(values, ".1", valuesToOmit = "c")values <- c("a", "b", "c") # Append ".1" to all values appendSuffix(values, ".1") # Append ".1" to all values but "c" appendSuffix(values, ".1", valuesToOmit = "c")
Creates a list of arguments from given argument lists and arguments. This function allows to create argument lists for function calls. You may start with some basic argument list and then merge other argument lists or single argument assignments into this list. Merging means that elements of the same name are overriden and elements with new names are appended.
arglist(..., warn.on.NULL = FALSE)arglist(..., warn.on.NULL = FALSE)
... |
list of arguments to this function. All unnamed arguments are
assumed to be argument lists which are merged using
|
warn.on.NULL |
if TRUE (default is FALSE) a warning is given if any of the arguments given to this function is NULL |
merged list of arguments
# define some default arguments args.default <- list(xlim = c(0, 10), ylim = c(0, 10), col = "red", lwd = 2) # call plot with the default arguments do.call(plot, arglist(args.default, x = 1:10)) # call plot with the default arguments but override the colour do.call(plot, arglist(args.default, x = 1:10, col = "blue"))# define some default arguments args.default <- list(xlim = c(0, 10), ylim = c(0, 10), col = "red", lwd = 2) # call plot with the default arguments do.call(plot, arglist(args.default, x = 1:10)) # call plot with the default arguments but override the colour do.call(plot, arglist(args.default, x = 1:10, col = "blue"))
Language Abbreviation to "sep" and "dec" argument
argsCsv(lng = "de")argsCsv(lng = "de")
lng |
"de" for German, "en" for Englisch |
list with elements sep (column separator), dec
(character used for decimal points)
Convert Array to Data Frame
arrayToDataFrame(x, name = deparse(substitute(x)))arrayToDataFrame(x, name = deparse(substitute(x)))
x |
an array |
name |
name to be given to the value column |
data frame with as many rows as there are elements in the input array
x. The data frame has one column per dimension of x
containing the dimension names and one additional column called according
to name containing the array values.
x <- array(1:24, dim = c(2, 3, 4), dimnames = list( c("a", "b"), c("x", "y", "z"), c("r", "s", "t", "u") )) arrayToDataFrame(x)x <- array(1:24, dim = c(2, 3, 4), dimnames = list( c("a", "b"), c("x", "y", "z"), c("r", "s", "t", "u") )) arrayToDataFrame(x)
Matrix to List of Matrix Columns
asColumnList(x)asColumnList(x)
x |
matrix |
list with as many elements as there are columns in x and each
element representing one column
x <- matrix(1:12, nrow = 3) column_list <- asColumnList(x) for (i in 1:ncol(x)) print(identical(column_list[[i]], x[, i]))x <- matrix(1:12, nrow = 3) column_list <- asColumnList(x) for (i in 1:ncol(x)) print(identical(column_list[[i]], x[, i]))
Use as.data.frame with stringsAsFactors = FALSE
asNoFactorDataFrame(...)asNoFactorDataFrame(...)
... |
passed to |
data_matrix <- matrix(LETTERS[1:6], nrow = 2) # as.data.frame() by default converts character to factor str(as.data.frame(data_matrix)) # asNoFactorDataFrame keeps character as character str(asNoFactorDataFrame(data_matrix))data_matrix <- matrix(LETTERS[1:6], nrow = 2) # as.data.frame() by default converts character to factor str(as.data.frame(data_matrix)) # asNoFactorDataFrame keeps character as character str(asNoFactorDataFrame(data_matrix))
Matrix to List of Matrix Rows
asRowList(x)asRowList(x)
x |
matrix |
list with as many elements as there are rows in x and each
element representing one row
x <- matrix(1:12, nrow = 3) row_list <- asRowList(x) for (i in 1:nrow(x)) print(identical(row_list[[i]], x[i, ]))x <- matrix(1:12, nrow = 3) row_list <- asRowList(x) for (i in 1:nrow(x)) print(identical(row_list[[i]], x[i, ]))
Make Sure that Strings End With Slash
assertFinalSlash(x, method = 1L)assertFinalSlash(x, method = 1L)
x |
vector of character |
method |
integer value specifying the implementation method. |
assertFinalSlash(c("a", "b", "c")) assertFinalSlash(c("a/", "b/", "c/")) assertFinalSlash(c("a//", "b", "c/")) # Use method 2 or 3 to replace multiple slashes with one slash assertFinalSlash(c("a//", "b", "c/"), method = 2) assertFinalSlash(c("a//", "b", "c/"), method = 3)assertFinalSlash(c("a", "b", "c")) assertFinalSlash(c("a/", "b/", "c/")) assertFinalSlash(c("a//", "b", "c/")) # Use method 2 or 3 to replace multiple slashes with one slash assertFinalSlash(c("a//", "b", "c/"), method = 2) assertFinalSlash(c("a//", "b", "c/"), method = 3)
Make sure that a matrix contains rows and columns of the given names in the given order.
assertRowsAndColumns(x, row_names = NULL, col_names = NULL, fill_value = 0)assertRowsAndColumns(x, row_names = NULL, col_names = NULL, fill_value = 0)
x |
A matrix |
row_names |
character vector of row names |
col_names |
character vector of column names |
fill_value |
value to fill a row or column with if a row or column does
not exist in |
m <- matrix(1:12, nrow = 3, ncol = 4, dimnames = list( rows = paste0("row", 1:3), cols = paste0("col", 1:4) )) # Add two rows, reverse order of rows, add one column, remove one column assertRowsAndColumns( m, row_names = paste0("row", 4:0), col_names = paste0("col", 0:2) )m <- matrix(1:12, nrow = 3, ncol = 4, dimnames = list( rows = paste0("row", 1:3), cols = paste0("col", 1:4) )) # Add two rows, reverse order of rows, add one column, remove one column assertRowsAndColumns( m, row_names = paste0("row", 4:0), col_names = paste0("col", 0:2) )
Provide all assignments of a list as objects in the environment
assignAll(x, pos = 1, ...)assignAll(x, pos = 1, ...)
x |
list of |
pos |
passed to |
... |
further arguments passed to |
Assign Argument Default Values in the Global Environment
assignArgumentDefaults(FUN)assignArgumentDefaults(FUN)
FUN |
a function (a closure or a primitive). If |
# Assign the default values of breakInSequence() in the global environment assignArgumentDefaults(kwb.utils::breakInSequence) # The argument "expectedDiff" is now in the global environment ls() # Its value is 1 which is the default value defined in the function definition expectedDiff# Assign the default values of breakInSequence() in the global environment assignArgumentDefaults(kwb.utils::breakInSequence) # The argument "expectedDiff" is now in the global environment ls() # Its value is 1 which is the default value defined in the function definition expectedDiff
assign variable in .GlobalEnv
assignGlobally(x, value)assignGlobally(x, value)
x |
name of variable |
value |
value of variable |
This function provides all (also non-exported) function definitions of this package in the Global environment. This is useful for debugging the code of a function that calls non-exported functions.
assignObjects()assignObjects()
## Not run: # Provide all functions of kwb.utils in the global environment assignObjects() ## End(Not run)## Not run: # Provide all functions of kwb.utils in the global environment assignObjects() ## End(Not run)
Assign all Package Objects to the Global Environment
assignPackageObjects(package)assignPackageObjects(package)
package |
package name |
assignPackageObjects("kwb.utils")assignPackageObjects("kwb.utils")
returns TRUE if data frame has at least one row, else FALSE
atLeastOneRowIn(dframe)atLeastOneRowIn(dframe)
dframe |
data frame |
String of n Backspaces
backspace(n)backspace(n)
n |
number of backspace characters |
vector of character of length one
update <- function(x) cat(backspace(3), x) x <- "value: 123" cat(x) cat(paste0(x, backspace(3), "987"))update <- function(x) cat(backspace(3), x) x <- "value: 123" cat(x) cat(paste0(x, backspace(3), "987"))
Find "Breaks" in a Sequence of Numbers
breakInSequence(x, expectedDiff = 1)breakInSequence(x, expectedDiff = 1)
x |
vector of numeric |
expectedDiff |
expected difference between elements in x. A bigger difference is recognised as a break. Default: 1 |
index of elements after which a break occurs or integer(0) if no break occurs at all
Call a function with the given arguments. Unnamed arguments are expected to
be lists containing further argument assignments. Multiple argument lists
are merged using arglist in the order of their appearence.
callWith(FUN, ...)callWith(FUN, ...)
FUN |
function to be called |
... |
(unnamed) lists containing argument assignments passed to
|
the return value is the return value of the function FUN.
# define some default arguments args.default <- list(xlim = c(0, 10), ylim = c(0, 10), col = "red", lwd = 2) # call plot with the default arguments callWith(plot, x = 1:10, args.default) # call plot with the default arguments but override the colour callWith(plot, x = 1:10, args.default, col = "blue")# define some default arguments args.default <- list(xlim = c(0, 10), ylim = c(0, 10), col = "red", lwd = 2) # call plot with the default arguments callWith(plot, x = 1:10, args.default) # call plot with the default arguments but override the colour callWith(plot, x = 1:10, args.default, col = "blue")
Call a Function with Argument Combinations from a Data Frame
callWithData( FUN, data, ..., threshold = 0.5, SIMPLIFY = TRUE, USE.NAMES = TRUE )callWithData( FUN, data, ..., threshold = 0.5, SIMPLIFY = TRUE, USE.NAMES = TRUE )
FUN |
function to be called |
data |
data frame with one column per argument of |
... |
further (constant) arguments to |
threshold |
if the ratio of unique value combinations in the relevant columns in data to all value combinations in these columns is below this threshold value then FUN will be called only with the unique value combinations. This should increase performance. |
SIMPLIFY |
passed to |
USE.NAMES |
passed to |
vector of length nrow(data) with the result values returned by
FUN
combis <- expand.grid(x = 1:2, y = c(10, 20, 30)) combis callWithData(`+`, combis)combis <- expand.grid(x = 1:2, y = c(10, 20, 30)) combis callWithData(`+`, combis)
Set the option "stringsAsFactors", run a function and reset the option.
callWithStringsAsFactors(stringsAsFactors, FUN, ...)callWithStringsAsFactors(stringsAsFactors, FUN, ...)
stringsAsFactors |
TRUE or FALSE. Before calling |
FUN |
function to be called |
... |
arguments passed to |
This function returns what FUN returns when called with the
arguments given in ...
option.bak <- getOption("stringsAsFactors") d1 <- callWithStringsAsFactors( TRUE, rbind, data.frame(id = 1, name = "Peter"), data.frame(id = 2, name = "Paul"), data.frame(id = 3, name = "Mary") ) d2 <- callWithStringsAsFactors( FALSE, rbind, data.frame(id = 1, name = "Peter"), data.frame(id = 2, name = "Paul"), data.frame(id = 3, name = "Mary") ) str(d1) str(d2) # The option "stringsAsFactors" has not changed! stopifnot(option.bak == getOption("stringsAsFactors"))option.bak <- getOption("stringsAsFactors") d1 <- callWithStringsAsFactors( TRUE, rbind, data.frame(id = 1, name = "Peter"), data.frame(id = 2, name = "Paul"), data.frame(id = 3, name = "Mary") ) d2 <- callWithStringsAsFactors( FALSE, rbind, data.frame(id = 1, name = "Peter"), data.frame(id = 2, name = "Paul"), data.frame(id = 3, name = "Mary") ) str(d1) str(d2) # The option "stringsAsFactors" has not changed! stopifnot(option.bak == getOption("stringsAsFactors"))
Print Debug Messages Before and After Running Code
catAndRun( messageText = "Running code", expr, newLine = 2L, dbg = TRUE, log_time = TRUE )catAndRun( messageText = "Running code", expr, newLine = 2L, dbg = TRUE, log_time = TRUE )
messageText |
text to be printed before running the code |
expr |
expressions to be run. Enclose more than one expression in curly braces |
newLine |
integer controlling new lines. 0: no extra new line, 1:
new line after |
dbg |
logical. If |
log_time |
logical. If |
This function returns the evaluation of expr. The result is
returned invisibly so that the result of an assignment as the last
expression in exprt does not show up on the console.
for (newLine in 0:3) { catAndRun("work hard", newLine = newLine, { cat("hard\nworking\n") }) cat("here.\n\n") }for (newLine in 0:3) { catAndRun("work hard", newLine = newLine, { cat("hard\nworking\n") }) cat("here.\n\n") }
Print Differences Between Two Vectors
catChanges(x, y)catChanges(x, y)
x |
vector |
y |
vector |
catChanges(c(1, 2, 3), c(1, 22, 3))catChanges(c(1, 2, 3), c(1, 22, 3))
Print Differences Between Two Vectors if Condition is Met
catChangesIf(dbg, x, y)catChangesIf(dbg, x, y)
dbg |
if |
x |
vector |
y |
vector |
This function evaluates an expression and returns, if warnings occurred, the warning message in the attribute "warningMessage" of the returned object.
catchWarning(expr, dbg = TRUE)catchWarning(expr, dbg = TRUE)
expr |
expression to be evaluated |
dbg |
if |
catchWarning(as.numeric("1.23")) result <- catchWarning(as.numeric("x")) result <- catchWarning(as.numeric("x"), dbg = FALSE) str(result)catchWarning(as.numeric("1.23")) result <- catchWarning(as.numeric("x")) result <- catchWarning(as.numeric("x"), dbg = FALSE) str(result)
Call cat If Condition Is Met
catIf(condition, ...)catIf(condition, ...)
condition |
if TRUE, cat is called, else not |
... |
arguments passed to cat |
Call cat on character vector, pasted with collapse = <new line>
catLines(x)catLines(x)
x |
vector of character representing text lines to be printed |
Print New Line Character to the Console if Condition is Met
catNewLineIf(condition)catNewLineIf(condition)
condition |
if |
Returns the condition, invisibly so that it can be reused
Stops if data frame frm does not contain all columns of which the names are given in reqCols.
checkForMissingColumns( frm, reqCols, do.stop = TRUE, dataFrameName = deparse(substitute(frm)) )checkForMissingColumns( frm, reqCols, do.stop = TRUE, dataFrameName = deparse(substitute(frm)) )
frm |
data frame |
reqCols |
vector of names of which existence in frm shall be checked |
do.stop |
if TRUE, stop() is called else warning() if a column is missing |
dataFrameName |
the name of the data frame to be shown in the error message if a column was missing |
TRUE if all required columns are available, else FALSE
Remove Leading/Trailing Empty Rows/Columns from Matrix
clipMatrix(m)clipMatrix(m)
m |
a matrix |
m with leading trailing empty rows (full of NA) removed
Set the given path in quotes so that in can be used in a command line
cmdLinePath(x)cmdLinePath(x)
x |
path to be quoted |
This is just a shortcut to paste(x, collapse = collapse)
collapsed(x, collapse = " ")collapsed(x, collapse = " ")
x |
vector of character |
collapse |
character string to separate the elements in x (passed to
|
Calculate the maxima within each column
colMaxima(dataFrame, na.rm = FALSE)colMaxima(dataFrame, na.rm = FALSE)
dataFrame |
data frame of which to calculate columnwise maxima |
na.rm |
passed to the |
Calculate the minima within each column
colMinima(dataFrame, na.rm = FALSE)colMinima(dataFrame, na.rm = FALSE)
dataFrame |
data frame of which to calculate columnwise minima |
na.rm |
passed to the |
Calculate the number of NA values within each column
colNaNumbers(dataFrame)colNaNumbers(dataFrame)
dataFrame |
data frame of which to calculate columnwise NA values |
Applies a statistical function to all columns of a data frame
colStatisticOneFunction(dataFrame, FUN, na.rm = FALSE)colStatisticOneFunction(dataFrame, FUN, na.rm = FALSE)
dataFrame |
a data frame of which statistics are to be calculated |
FUN |
statistical function to be applied on each column of dataFrame possible values: "sum", "mean", "min", "max", "number.na" (number of NA values), "length" (number of values) |
na.rm |
if TRUE, NA values are removed before applying the statistical function |
applies statistical functions to all columns of a data frame
colStatistics( dataFrame, functions = c("sum", "mean", "min", "max", "number.na", "length"), na.rm = FALSE, functionColumn = FALSE )colStatistics( dataFrame, functions = c("sum", "mean", "min", "max", "number.na", "length"), na.rm = FALSE, functionColumn = FALSE )
dataFrame |
data frame with numeric columns only |
functions |
vector of statistical functions to be applied on each column of dataFrame possible values: "sum", "mean", "min", "max", "number.na" (number of NA values), "length" (number of values) |
na.rm |
if TRUE, NA values are removed before applying the statistical function(s) |
functionColumn |
if TRUE, a column containing the function name is contained in the result data frame, otherwise the function names become the row names of the result data frame |
Column Descriptor
columnDescriptor(match = ".*", fixed = FALSE)columnDescriptor(match = ".*", fixed = FALSE)
match |
pattern or fixed text to match in header line |
fixed |
if TRUE, match is taken as a fixed string to be looked for in the header line, otherwise it is interpreded as a regular expression |
Convert Column in Data Frame To Date
columnToDate(df, column, dbg = TRUE)columnToDate(df, column, dbg = TRUE)
df |
data frame |
column |
name of column in |
dbg |
if |
df with column converted to class Date with
as.Date
df <- data.frame(id = 1:2, date = c("2018-10-23", "2018-10-23")) str(df) df <- columnToDate(df, "date") str(df)df <- data.frame(id = 1:2, date = c("2018-10-23", "2018-10-23")) str(df) df <- columnToDate(df, "date") str(df)
Calculate the percentage (value divided by sum of values in the column) for each column
columnwisePercentage(x, default = 0, digits = 1)columnwisePercentage(x, default = 0, digits = 1)
x |
two dimensional numeric data structure |
default |
default value to be used if the calculated percentage is
|
digits |
number of digits (default: 1) to which the resulting
percentages are to be rounded. Set to |
# Create a random matrix of integer values M1 <- matrix(sample(100, 12), nrow = 4, dimnames = list(LETTERS[1:4], 1:3)) # Introduce some NA values <- as.numeric(M1) values[sample(length(values), 3)] <- NA M2 <- matrix(values, nrow = nrow(M1), dimnames = dimnames(M1)) M1 columnwisePercentage(M1) M2 columnwisePercentage(M2) columnwisePercentage(M2, default = 0)# Create a random matrix of integer values M1 <- matrix(sample(100, 12), nrow = 4, dimnames = list(LETTERS[1:4], 1:3)) # Introduce some NA values <- as.numeric(M1) values[sample(length(values), 3)] <- NA M2 <- matrix(values, nrow = nrow(M1), dimnames = dimnames(M1)) M1 columnwisePercentage(M1) M2 columnwisePercentage(M2) columnwisePercentage(M2, default = 0)
Combine Two Vectors Alternatingly
combineAlternatingly(a, b)combineAlternatingly(a, b)
a |
first vector |
b |
second vector |
vector x with all x[c(1, 3, 5, ...)] == a and all
x[c(2, 4, 6, ...)] == b
a <- paste0("a", 1:5) b <- paste0("b", 1:5) combineAlternatingly(a, b) combineAlternatingly(b, a) combineAlternatingly(list(a = 1, b = 2), list(c = 3, d = 4))a <- paste0("a", 1:5) b <- paste0("b", 1:5) combineAlternatingly(a, b) combineAlternatingly(b, a) combineAlternatingly(list(a = 1, b = 2), list(c = 3, d = 4))
Paste With Collapse = ","
commaCollapsed(x)commaCollapsed(x)
x |
vector of character |
Common Names in two Objects with Names Attribute
commonNames(x, y)commonNames(x, y)
x |
object with names attribute, e.g. data.frame, named vector |
y |
object with names attribute, e.g. data.frame, named vector |
vector of names occurring in both x and y
x <- data.frame(a = 1:2, b = 2:3) y <- c(a = 1, c = 2)x <- data.frame(a = 1:2, b = 2:3) y <- c(a = 1, c = 2)
Compare two data frames by columns
compareDataFrames( x, y, dbg = FALSE, xname = deparse(substitute(x)), yname = deparse(substitute(y)) )compareDataFrames( x, y, dbg = FALSE, xname = deparse(substitute(x)), yname = deparse(substitute(y)) )
x |
first data frame |
y |
second data frame |
dbg |
if |
xname |
name of first data frame to appear in the output if |
yname |
name of second data frame to appear in the output if |
list of logical
x <- data.frame(a = 1:2, b = 2:3) y <- x test1 <- all(unlist(compareDataFrames(x, y))) z <- compareDataFrames(x, y[, c("b", "a")]) expectedFalse <- c("identical", "identicalExceptAttributes", "sameColumnNames") test2 <- all(names(which(!unlist(z))) == expectedFalse) test1 && test2x <- data.frame(a = 1:2, b = 2:3) y <- x test1 <- all(unlist(compareDataFrames(x, y))) z <- compareDataFrames(x, y[, c("b", "a")]) expectedFalse <- c("identical", "identicalExceptAttributes", "sameColumnNames") test2 <- all(names(which(!unlist(z))) == expectedFalse) test1 && test2
Prints the result of comparing the values of two vectors with each other (which values are in the first vector but not in the second one and which values are in the second vector but not in the first one) on the screen.
compareSets( x, y, subject = "Values", xname = deparse(substitute(x)), yname = deparse(substitute(y)) )compareSets( x, y, subject = "Values", xname = deparse(substitute(x)), yname = deparse(substitute(y)) )
x |
first vector |
y |
second vector |
subject |
name of objects to be compared that will appear in the
message. Default: |
xname |
optional name of the first vector that will be used in the message |
yname |
optional name of the second vector that will be used in the message |
compareSets(1:10, 3:13) compareSets(1:10, 3:13, "numbers", "set 1", "set 2")compareSets(1:10, 3:13) compareSets(1:10, 3:13, "numbers", "set 1", "set 2")
Check for nul String in File
containsNulString(filepath)containsNulString(filepath)
filepath |
full path to file to be checked |
TRUE if first two bytes of file are <FF><FE>, else
FALSE
This function allows you to change the format (such as column delimiter,
decimal character) of a CSV file. It uses read.table to read a
CSV file and write.table to rewrite the file with modified
format to a new file. All arguments of read.table and
write.table are supported. Arguments that are provided by both
functions appear as two arguments <argument_name>_in and
<argument_name>_out in this function.
convertCsvFile( file_in, sep_in = formals(utils::read.table)$sep, sep_out = sep_in, dec_in = formals(utils::read.table)$dec, dec_out = dec_in, file_out = NULL, header = TRUE, quote_in = formals(utils::read.table)$quote, quote_out = formals(utils::write.table)$quote, row.names_in = formals(utils::read.table)$row.names, col.names_in = formals(utils::read.table)$col.names, row.names_out = FALSE, col.names_out = TRUE, fileEncoding_in = formals(utils::read.table)$fileEncoding, fileEncoding_out = fileEncoding_in, dbg = TRUE, ... )convertCsvFile( file_in, sep_in = formals(utils::read.table)$sep, sep_out = sep_in, dec_in = formals(utils::read.table)$dec, dec_out = dec_in, file_out = NULL, header = TRUE, quote_in = formals(utils::read.table)$quote, quote_out = formals(utils::write.table)$quote, row.names_in = formals(utils::read.table)$row.names, col.names_in = formals(utils::read.table)$col.names, row.names_out = FALSE, col.names_out = TRUE, fileEncoding_in = formals(utils::read.table)$fileEncoding, fileEncoding_out = fileEncoding_in, dbg = TRUE, ... )
file_in |
path to input file |
sep_in |
column separator in input file |
sep_out |
column separator in output file |
dec_in |
decimal character in input file |
dec_out |
decimal character inoutput file |
file_out |
path to output file |
header |
passed to |
quote_in |
passed as |
quote_out |
passed as |
row.names_in |
passed as |
col.names_in |
passed as |
row.names_out |
passed as |
col.names_out |
passed as |
fileEncoding_in |
passed as |
fileEncoding_out |
passed as |
dbg |
if |
... |
further arguments passed to either |
path to the created CSV file
# Write the iris dataset to a temporary file with "," as column separator csv_in <- tempfile(fileext = ".csv") write.table(iris, csv_in, row.names = FALSE) # Review the first lines of the file catLines(readLines(csv_in, 6)) # Convert the column separator (from " " which was the default) to ";" csv_out <- convertCsvFile(csv_in, sep_out = ";") # Review the result catLines(readLines(csv_out, 6)) # Delete the file so that it can be recreated unlink(csv_out) # Convert the column separator and the decimal character csv_out <- convertCsvFile(csv_in, sep_out = ";", dec_out = ",") # Review the result catLines(readLines(csv_out, 6))# Write the iris dataset to a temporary file with "," as column separator csv_in <- tempfile(fileext = ".csv") write.table(iris, csv_in, row.names = FALSE) # Review the first lines of the file catLines(readLines(csv_in, 6)) # Convert the column separator (from " " which was the default) to ";" csv_out <- convertCsvFile(csv_in, sep_out = ";") # Review the result catLines(readLines(csv_out, 6)) # Delete the file so that it can be recreated unlink(csv_out) # Convert the column separator and the decimal character csv_out <- convertCsvFile(csv_in, sep_out = ";", dec_out = ",") # Review the result catLines(readLines(csv_out, 6))
Copy Attributes Between Two Objects
copyAttributes(x, y, attrNames)copyAttributes(x, y, attrNames)
x |
object to which to copy attributes of y |
y |
object from which to copy attributes to x |
attrNames |
vector of character containing the names of attributes in
|
x <- structure(1, a = 2, b = 3) y <- structure(2, c = 4) copyAttributes(x, y, "c")x <- structure(1, a = 2, b = 3) y <- structure(2, c = 4) copyAttributes(x, y, "c")
Copy the full directory structure from a source directory to a target directory
copyDirectoryStructure( sourcedir, targetdir, excludePattern = "^$", recursive = TRUE, dbg = TRUE )copyDirectoryStructure( sourcedir, targetdir, excludePattern = "^$", recursive = TRUE, dbg = TRUE )
sourcedir |
path to the source directory |
targetdir |
path to the target directory |
excludePattern |
pattern matching directory names to be excluded from the copying process |
recursive |
if TRUE (default) the full tree of directories and subdirectories is copied, otherwise only the top-level directories |
dbg |
if TRUE (default) debug messages are shown |
This function invisibly returns a vector of character containing the full paths of the directories that were created.
Copy List Elements into a List of Lists
copyListElements(x, y, name = deparse(substitute(y)))copyListElements(x, y, name = deparse(substitute(y)))
x |
list of lists |
y |
list of elements |
name |
name of target list element |
x with each sublist being extended by list element name
having been taken from y
x <- list(list(a = 1), list(b = 2), list(c = 3)) y <- list("b1", "b2", "b3") str(copyListElements(x, y, "b"))x <- list(list(a = 1), list(b = 2), list(c = 3)) y <- list("b1", "b2", "b3") str(copyListElements(x, y, "b"))
Count NA in one Column of a Data Frame
countNaInColumn(data, column)countNaInColumn(data, column)
data |
data frame |
column |
column name |
number of NA in column of data
Count or Sum Up Values Within Groups of rows
countOrSum(x, by = NULL, sum.up = NULL)countOrSum(x, by = NULL, sum.up = NULL)
x |
data frame |
by |
vector of names of columns in |
sum.up |
name of column in |
object of class xtabs with as many dimensions as there are
values in by
# Create a data frame with example data x <- data.frame( Group = rep(c("A", "B", "C"), 4), Even = rep(c(FALSE, TRUE), 6), Value = seq_len(12) ) # Count the number of rows for each group countOrSum(x, "Group") countOrSum(x, c("Group", "Even")) # Sum up the values in column "Value" for each group countOrSum(x, "Group", sum.up = "Value") countOrSum(x, c("Group", "Even"), sum.up = "Value")# Create a data frame with example data x <- data.frame( Group = rep(c("A", "B", "C"), 4), Even = rep(c(FALSE, TRUE), 6), Value = seq_len(12) ) # Count the number of rows for each group countOrSum(x, "Group") countOrSum(x, c("Group", "Even")) # Sum up the values in column "Value" for each group countOrSum(x, "Group", sum.up = "Value") countOrSum(x, c("Group", "Even"), sum.up = "Value")
Create Function to Safely Access Data Frame Columns or List Elements
createAccessor(x)createAccessor(x)
x |
a data frame or a list |
getcol <- createAccessor(data.frame(a = 1:2, b = 2:3)) getcol("a") getcol("b") getcol(c("b", "a")) # getcol("c") # error with info about existing columnsgetcol <- createAccessor(data.frame(a = 1:2, b = 2:3)) getcol("a") getcol("b") getcol(c("b", "a")) # getcol("c") # error with info about existing columns
Create a Directory including required "upward" Folders
createDirAndReturnPath(path, dbg = TRUE, confirm = FALSE)createDirAndReturnPath(path, dbg = TRUE, confirm = FALSE)
path |
character string representing the path to the directory to be created |
dbg |
if |
confirm |
if |
created path or NULL if the path could not be created
Create Directories
createDirectories(paths, ...)createDirectories(paths, ...)
paths |
paths to directories to be created |
... |
further arguments passed to |
paths to created directories
Create Directory if it does not exist
createDirectory(dir.to.create, dbg = TRUE, confirm = FALSE)createDirectory(dir.to.create, dbg = TRUE, confirm = FALSE)
dir.to.create |
character string representing the path to the directory to be created |
dbg |
if |
confirm |
if |
created path or NULL if the path could not be created
Create Function to Provide Package Objects in Global Environment
createFunctionAssignObjects(package)createFunctionAssignObjects(package)
package |
name of package for which to create a shortcut to
|
This function returns a function that internally calls
assignPackageObjects(package = package)
provideFunctions <- createFunctionAssignObjects("kwb.utils") ## Not run: provideFunctions() ## End(Not run)provideFunctions <- createFunctionAssignObjects("kwb.utils") ## Not run: provideFunctions() ## End(Not run)
Create Function to Compose Path in Package
createFunctionExtdataFile(package)createFunctionExtdataFile(package)
package |
name of package for which to create a shortcut to
|
This function returns a function that internally calls
system.file("extdata", ..., package = package)
extdataFile <- createFunctionExtdataFile("kwb.utils") dir(extdataFile())extdataFile <- createFunctionExtdataFile("kwb.utils") dir(extdataFile())
This function helps you create strings that can be used as identifiers.
createIdAlong(x, base_name = NULL)createIdAlong(x, base_name = NULL)
x |
vector of objects for which to create identifiers |
base_name |
base string to which the hexadecimal suffixes are to be
appended. By default the name of the object |
vector of character as long as x
# Create ids for 32 numbers createIdAlong(1:32, "number") # Take base name from x, with the plural's "s" removed numbers <- 1:32 createIdAlong(numbers)# Create ids for 32 numbers createIdAlong(1:32, "number") # Take base name from x, with the plural's "s" removed numbers <- 1:32 createIdAlong(numbers)
Create a matrix by giving row and column names and with all elements being set to a default value
createMatrix( rowNames, colNames = rowNames, value = 0, name.row = NULL, name.col = NULL )createMatrix( rowNames, colNames = rowNames, value = 0, name.row = NULL, name.col = NULL )
rowNames |
character vector of row names to be given to the matrix |
colNames |
character vector of column names to be given to the matrix |
value |
value to be given to each matrix element |
name.row |
optional. Name to be given to the row dimension |
name.col |
optional. Name to be given to the column dimension |
matrix with rowNames as row names and colNames as
column names, filled with value at each position
## Initialise a matrix with rows A to E and columns x to z of value -1 createMatrix(c("A", "B", "C", "D", "E"), c("x", "y", "z"), -1) ## By default the column names are assumed to be equal to the row names createMatrix(c("A", "B", "C")) ## Initialise a square matrix with NA createMatrix(c("A", "B", "C"), value = NA) ## Give a name to the row dimension createMatrix(c("A", "B", "C"), name.row = "Letters")## Initialise a matrix with rows A to E and columns x to z of value -1 createMatrix(c("A", "B", "C", "D", "E"), c("x", "y", "z"), -1) ## By default the column names are assumed to be equal to the row names createMatrix(c("A", "B", "C")) ## Initialise a square matrix with NA createMatrix(c("A", "B", "C"), value = NA) ## Give a name to the row dimension createMatrix(c("A", "B", "C"), name.row = "Letters")
Create a File Storing a Password in Encrypted Form
createPasswordFile(account = NULL, keyFile, passwordFile, password = NULL)createPasswordFile(account = NULL, keyFile, passwordFile, password = NULL)
account |
optional. Name of account the user is asked to enter the password for. Only used for the input prompt. |
keyFile |
path to the file containing the encryption/decryption key,
as generated by |
passwordFile |
path to the password file to be created. An existing file will be overwritten! |
password |
password for account. If |
This function returns an object that implements the methods list(),
save(), load(), remove() that list, store, load or
remove, respectively .rds or .RData files. The object is associated to a
folder that is given to this function.
createStorage(path, type = "rds")createStorage(path, type = "rds")
path |
path to the folder in which to store the RDS files. If the folder does not exist it is attempted to be created. |
type |
one of |
list with "member functions" list(), save(),
load(), remove(), and variables path, type
# Create an empty test folder path <- file.path(tempdir(), "test") dir.create(path) # Create a storage object pointing to a temporary test folder storage <- kwb.utils::createStorage(path) # At the beginning, the storage is empty storage$list() # Store objects apple <- 5 storage$save(apple, banana = list("Hello", "World")) ## Not run: # List the objects storage$list() # Retrieve an object storage$load("banana") # Remove objects storage$remove("apple") storage$remove("banana") # The storage is empty again storage$list() ## End(Not run)# Create an empty test folder path <- file.path(tempdir(), "test") dir.create(path) # Create a storage object pointing to a temporary test folder storage <- kwb.utils::createStorage(path) # At the beginning, the storage is empty storage$list() # Store objects apple <- 5 storage$save(apple, banana = list("Hello", "World")) ## Not run: # List the objects storage$list() # Retrieve an object storage$load("banana") # Remove objects storage$remove("apple") storage$remove("banana") # The storage is empty again storage$list() ## End(Not run)
CSV Text to Data Frame
csvTextToDataFrame(text, ...)csvTextToDataFrame(text, ...)
text |
character vector representing lines of comma separated values |
... |
arguments passed to |
For an example see encode.
decode(x)decode(x)
x |
vector of encoded character strings as returned by
|
vector of decoded character strings
Return a Default Value for Values Meeting a Condition
defaultIf(FUN.test, x, default, count = FALSE)defaultIf(FUN.test, x, default, count = FALSE)
FUN.test |
function returning vector of logical, to be applied to
|
x |
vector in which to set default values |
default |
value to be set in |
count |
if |
Return the given object or a default value if the object is NA
defaultIfNA(x, default, count = FALSE)defaultIfNA(x, default, count = FALSE)
x |
vector possibly containing NA values |
default |
default value that is returned if |
count |
if |
x if x is not NA and default otherwise
defaultIfNA(NA, "default") # returns the default value defaultIfNA("actual", "default") # returns the "actual" valuedefaultIfNA(NA, "default") # returns the default value defaultIfNA("actual", "default") # returns the "actual" value
Return the given object or a default value if the object is NULL
defaultIfNULL(x, default, count = FALSE)defaultIfNULL(x, default, count = FALSE)
x |
R object to be checked for NULL |
default |
default value that is returned if |
count |
if |
x if x is not NULL and default otherwise
defaultIfNULL(NULL, "default") # returns the default value defaultIfNULL("actual", "default") # returns the "actual" valuedefaultIfNULL(NULL, "default") # returns the default value defaultIfNULL("actual", "default") # returns the "actual" value
Return the given object or a default value if the object is 0 (zero)
defaultIfZero(x, default, count = FALSE)defaultIfZero(x, default, count = FALSE)
x |
vector possibly containing zeroes |
default |
value to be used instead of zero |
count |
if |
x if x is not 0 and default otherwise. The
returned object has an attribute count containing the number of
values that have been set to the default value.
defaultIfZero(c(1, 2, 0, 4, 5, 0, 6), NA) # returns the default value (NA) (out <- defaultIfZero(1:6, NA, count = TRUE)) # returns the "actual" values # The number of values that were zero is returned in the attribute "count" attr(out, "count")defaultIfZero(c(1, 2, 0, 4, 5, 0, 6), NA) # returns the default value (NA) (out <- defaultIfZero(1:6, NA, count = TRUE)) # returns the "actual" values # The number of values that were zero is returned in the attribute "count" attr(out, "count")
If x is numeric and all values are whole numbers use the sequence between the smallest and the highest value
defaultLevels(x, step = 1)defaultLevels(x, step = 1)
x |
numeric or character vector |
step |
step to be used in sequence generation |
if x is numeric the sequence between the lowest and highest
value in x with the given step is returned. If x is a
vector of character strings, the sorted unique values are returned.
defaultLevels(c(1, 3, 4, 5, 4)) defaultLevels(c(1920, 1950, 1970), step = 10)defaultLevels(c(1, 3, 4, 5, 4)) defaultLevels(c(1920, 1950, 1970), step = 10)
Default Windows Program Folders
defaultWindowsProgramFolders()defaultWindowsProgramFolders()
Get the path to your desktop
desktop(osType = .OStype())desktop(osType = .OStype())
osType |
Optional. Type of operating system, one of |
character string representing the path to your desktop
Differences between Matrix Rows
diffrows(x)diffrows(x)
x |
matrix |
matrix with one row less than in input matrix x and each row
i representing the difference x[i+1, ]-x[i, ] between rows
i+1 and i in x
x <- matrix(1:12, nrow = 3) d <- diffrows(x) x[2, ] - x[1, ] == d[1, ] x[3, ] - x[2, ] == d[2, ]x <- matrix(1:12, nrow = 3) d <- diffrows(x) x[2, ] - x[1, ] == d[1, ] x[3, ] - x[2, ] == d[2, ]
Width and Height of a DIN A4 Paper
DIN.A4()DIN.A4()
The base function dirname may fail if the path passed is too
long. This version checks if the call of dirname() failed and gives
a clear error message.
directoryName(x)directoryName(x)
x |
a file path of which to get the path to the directory only |
path to directory of file path given in x
## Not run: directoryName(repeated("verylongpath/", 50)) ## End(Not run)## Not run: directoryName(repeated("verylongpath/", 50)) ## End(Not run)
Drop Array Dimension(s) of Length One
dropDim(x, dimension = which(dim(x) == 1))dropDim(x, dimension = which(dim(x) == 1))
x |
an array |
dimension |
number(s) of dimension(s) of length one to be removed |
array with dimensions of which the numbers are given in
dimension removed
# Define an array of two matrices A <- array( 1:8, dim = c(2, 2, 2), dimnames = list( paste0("x", 1:2), paste0("y", 1:2), paste0("z", 1:2)) ) # The aim is to select the first column of the first matrix with # the matrix structure being kept. This cannot be done with the # standard "[" operator. It has indeed a "drop" argument but this # acts on all dimensions: # By default, drop is TRUE. The result is a named vector A[, 1, 1] # With drop = FALSE we get a 3D-array again and not a matrix A[, 1, 1, drop = FALSE] # Use dropDim to remove the third dimension of an array that # has already one dimension of length one dropDim(A[, 1, 1, drop = FALSE], dimension = 3)# Define an array of two matrices A <- array( 1:8, dim = c(2, 2, 2), dimnames = list( paste0("x", 1:2), paste0("y", 1:2), paste0("z", 1:2)) ) # The aim is to select the first column of the first matrix with # the matrix structure being kept. This cannot be done with the # standard "[" operator. It has indeed a "drop" argument but this # acts on all dimensions: # By default, drop is TRUE. The result is a named vector A[, 1, 1] # With drop = FALSE we get a 3D-array again and not a matrix A[, 1, 1, drop = FALSE] # Use dropDim to remove the third dimension of an array that # has already one dimension of length one dropDim(A[, 1, 1, drop = FALSE], dimension = 3)
Drop Unused Factor Levels in all Factor Columns
dropUnusedFactorLevels(data, dbg = TRUE)dropUnusedFactorLevels(data, dbg = TRUE)
data |
data frame in which to remove unused levels in all columns that are factors |
dbg |
if |
data with unused factors removed in all columns being factors
# Create an example data frame with two factor columns data <- data.frame( id = 1:3, factor_1 = factor(c("a", "b", "a"), levels = c("a", "b", "c")), factor_2 = factor(c("x", "x", "y"), levels = c("x", "y", "z")), no_factor = c("A", "B", "C"), stringsAsFactors = FALSE ) # Review the structure of the data frame str(data) # Review the structure of the data frame with unused factors removed str(dropUnusedFactorLevels(data))# Create an example data frame with two factor columns data <- data.frame( id = 1:3, factor_1 = factor(c("a", "b", "a"), levels = c("a", "b", "c")), factor_2 = factor(c("x", "x", "y"), levels = c("x", "y", "z")), no_factor = c("A", "B", "C"), stringsAsFactors = FALSE ) # Review the structure of the data frame str(data) # Review the structure of the data frame with unused factors removed str(dropUnusedFactorLevels(data))
Encode a Vector of Character
encode(x, level = 1, chars = printable_chars(level))encode(x, level = 1, chars = printable_chars(level))
x |
vector of character |
level |
one of 1, 2, or 3 defining which character set to use for
encoding, see |
chars |
vector of characters to be used for encoding |
vector of character as long as x with each element containing
the encoded version of the corresponding element in x. The returned
vector has an attribute codes being a named vector. This vector
contains the unique values in x as elements. Each element is named
by the code that was used to encode the corresponding element.
x <- c("very-long-word", "very-long-word", "very-very-long-word") encoded <- encode(x) encoded decode(encoded)x <- c("very-long-word", "very-long-word", "very-very-long-word") encoded <- encode(x) encoded decode(encoded)
Enlarge a vector to the given length, filling with given element
enlargeVector(x, length.out, fill.with = "")enlargeVector(x, length.out, fill.with = "")
x |
vector |
length.out |
desired length of output vector |
fill.with |
element to fill the vector up with (default: "") |
x, filled up with fill.with to a final length of
length.out
kwb.utils::enlargeVector(1:5, 10, fill.with = 0) kwb.utils::enlargeVector(1:5, 10, fill.with = NA) kwb.utils::enlargeVector(c("a", "b", "c"), 10) kwb.utils::enlargeVector(c("a", "b", "c"), 10, fill.with = "?")kwb.utils::enlargeVector(1:5, 10, fill.with = 0) kwb.utils::enlargeVector(1:5, 10, fill.with = NA) kwb.utils::enlargeVector(c("a", "b", "c"), 10) kwb.utils::enlargeVector(c("a", "b", "c"), 10, fill.with = "?")
Exclude all NULL Entries from a List
excludeNULL(x, dbg = TRUE)excludeNULL(x, dbg = TRUE)
x |
a list |
dbg |
if |
list x with all NULL entries excluded
L <- list(a = 1, b = NULL, c = "three") L excludeNULL(L)L <- list(a = 1, b = NULL, c = "three") L excludeNULL(L)
Same as expand.grid but with stringsAsFactors =
FALSE by default and with the values of the first argument being changed
last, not first.
expandGrid(..., stringsAsFactors = FALSE)expandGrid(..., stringsAsFactors = FALSE)
... |
arguments passed to |
stringsAsFactors |
passed to |
persons <- c("Peter", "Paul", "Mary") fruits <- c("apple", "pear") # With expand.grid() the values of the first argument change first... (grid_1 <- expand.grid(person = persons, fruit = fruits)) #... with expandGrid() they change last. (grid_2 <- expandGrid(person = persons, fruit = fruits)) # With expand.grid() character strings are converted to factors by default... str(grid_1) # ... with expandGrid() character strings are not converted by default. # Also, there is no attribute "out.attrs" as it is set by expand.grid(). str(grid_2)persons <- c("Peter", "Paul", "Mary") fruits <- c("apple", "pear") # With expand.grid() the values of the first argument change first... (grid_1 <- expand.grid(person = persons, fruit = fruits)) #... with expandGrid() they change last. (grid_2 <- expandGrid(person = persons, fruit = fruits)) # With expand.grid() character strings are converted to factors by default... str(grid_1) # ... with expandGrid() character strings are not converted by default. # Also, there is no attribute "out.attrs" as it is set by expand.grid(). str(grid_2)
Path to File in Installed Package
extdataFile(..., must_exist = TRUE, dbg = FALSE)extdataFile(..., must_exist = TRUE, dbg = FALSE)
... |
parts of the file path to be passed to |
must_exist |
if |
dbg |
if |
path to file in the package installation folder in the R library or "" if the path does not exist
path to the specified file
# List the files provided in the "extdata" folder of kwb.utils dir(extdataFile())# List the files provided in the "extdata" folder of kwb.utils dir(extdataFile())
Extend the Limits of a Range Vector
extendLimits(limits, left = 0.05, right = left, absolute = FALSE)extendLimits(limits, left = 0.05, right = left, absolute = FALSE)
limits |
vector of two elements as e.g. used for xlim or ylim |
left |
percentage of limit range (absolute == FALSE) or absolute value (absolute == TRUE) by which the left limit is extended to the left. |
right |
percentage of limit range (absolute == FALSE) or absolute value (absolute == TRUE) by which the right limit is extended to the right. |
absolute |
Default: FALSE |
Extract Row Ranges by Pattern
extractRowRanges( x, pattern, column = NULL, starts = NULL, startOffset = 1L, stopOffset = 1L, nameByMatch = FALSE, nameColumnsByMatch = TRUE, renumber = TRUE )extractRowRanges( x, pattern, column = NULL, starts = NULL, startOffset = 1L, stopOffset = 1L, nameByMatch = FALSE, nameColumnsByMatch = TRUE, renumber = TRUE )
x |
data frame or matrix or vector of character (representing e.g. the rows read from a text file) |
pattern |
pattern to be searched for, either in |
column |
name of column in which to search for pattern if
|
starts |
optional. Vector of indices representing the starts of the row
ranges to be extracted. This argument overrides |
startOffset |
row offset to be added to row number in which the pattern matches |
stopOffset |
row offset to be subtracted from row number in which the pattern matches |
nameByMatch |
logical. if |
nameColumnsByMatch |
if |
renumber |
if |
list of data frames or list of matrices or list of vectors of
character. Each list element represents one section of the input, found
between two consecutive matches of pattern.
textLines <- c( "Date,Value", "1.1.,1", "2.1.,2", ",", "Date,Value", "3.1.,3", "4.1.,4", ",", "Date,Value", "5.1.,5", "6.1.,6" ) # Convert textLines to data frame. The function should be able to handle both. (dataFrame <- read.table(text = textLines, sep = ",", stringsAsFactors = FALSE)) # stopOffset = 2L: skip empty line at the bottom of each sub-table extractRowRanges( textLines, pattern = "Date", stopOffset = 2L, ) extractRowRanges( dataFrame, pattern = "Date", column = "V1", stopOffset = 2L ) # Extract sections after a header line # startOffset = 2L: skip empty line after header "topic: ..." textLines <- c( "topic: A", "", " a.1", " a.2", " a.3", "topic: B", "", " b.1", "topic: C", "", " c.1", " c.2" ) extractRowRanges( textLines, pattern = "topic", startOffset = 2L, nameByMatch = TRUE )textLines <- c( "Date,Value", "1.1.,1", "2.1.,2", ",", "Date,Value", "3.1.,3", "4.1.,4", ",", "Date,Value", "5.1.,5", "6.1.,6" ) # Convert textLines to data frame. The function should be able to handle both. (dataFrame <- read.table(text = textLines, sep = ",", stringsAsFactors = FALSE)) # stopOffset = 2L: skip empty line at the bottom of each sub-table extractRowRanges( textLines, pattern = "Date", stopOffset = 2L, ) extractRowRanges( dataFrame, pattern = "Date", column = "V1", stopOffset = 2L ) # Extract sections after a header line # startOffset = 2L: skip empty line after header "topic: ..." textLines <- c( "topic: A", "", " a.1", " a.2", " a.3", "topic: B", "", " b.1", "topic: C", "", " c.1", " c.2" ) extractRowRanges( textLines, pattern = "topic", startOffset = 2L, nameByMatch = TRUE )
Extract substrings defined by regular expressions from a vector of strings
extractSubstring(pattern, x, index, stringsAsFactors = FALSE)extractSubstring(pattern, x, index, stringsAsFactors = FALSE)
pattern |
regular expression containing parts in pairs of opening and closing parentheses defining the part(s) to be extracted |
x |
vector of character strings |
index |
index(es) of parenthesized subexpression(s) to be extracted. If
the length of |
stringsAsFactors |
if |
# Define pattern matching a date pattern <- "([^ ]+), ([0-9]+) of ([^ ]+)" # Extract single sub expressions from one string datestring <- "Thursday, 8 of December" extractSubstring(pattern, datestring, 1) # ""Thursday"" extractSubstring(pattern, datestring, 2) # "8" extractSubstring(pattern, datestring, 3) # "December" # Extract single sub expressions from a vector of strings datestrings <- c("Thursday, 8 of December", "Tuesday, 14 of January") extractSubstring(pattern, datestrings, 1) # "Thursday" "Tuesday" extractSubstring(pattern, datestrings, 2) # "8" "14" extractSubstring(pattern, datestrings, 3) # "December" "January" # Extract more than one subexpression at once -> data.frame extractSubstring(pattern, datestrings, 1:3) # subexp.1 subexp.2 subexp.3 # 1 Thursday 8 December # 2 Tuesday 14 January # Name the sub expressions by naming their number in index (3rd argument) extractSubstring(pattern, datestrings, index = c(weekday = 1, 2, month = 3)) # weekday subexp.2 month # 1 Thursday 8 December # 2 Tuesday 14 January# Define pattern matching a date pattern <- "([^ ]+), ([0-9]+) of ([^ ]+)" # Extract single sub expressions from one string datestring <- "Thursday, 8 of December" extractSubstring(pattern, datestring, 1) # ""Thursday"" extractSubstring(pattern, datestring, 2) # "8" extractSubstring(pattern, datestring, 3) # "December" # Extract single sub expressions from a vector of strings datestrings <- c("Thursday, 8 of December", "Tuesday, 14 of January") extractSubstring(pattern, datestrings, 1) # "Thursday" "Tuesday" extractSubstring(pattern, datestrings, 2) # "8" "14" extractSubstring(pattern, datestrings, 3) # "December" "January" # Extract more than one subexpression at once -> data.frame extractSubstring(pattern, datestrings, 1:3) # subexp.1 subexp.2 subexp.3 # 1 Thursday 8 December # 2 Tuesday 14 January # Name the sub expressions by naming their number in index (3rd argument) extractSubstring(pattern, datestrings, index = c(weekday = 1, 2, month = 3)) # weekday subexp.2 month # 1 Thursday 8 December # 2 Tuesday 14 January
Get Extension of Full File Paths
fileExtension(x)fileExtension(x)
x |
vector of file paths |
# Define example paths paths <- c("C:/example/file.csv", "file2.txt", "D:/e/f/ghi.jkl.zip") # Get the file name extensions fileExtension(paths) # Empty string is returned for paths without file name extensions fileExtension("C:/NEWS")# Define example paths paths <- c("C:/example/file.csv", "file2.txt", "D:/e/f/ghi.jkl.zip") # Get the file name extensions fileExtension(paths) # Empty string is returned for paths without file name extensions fileExtension("C:/NEWS")
Finds the positions in a vector where the value changes an returns the "index
regions", i.e. the regions between indices starts_at and
ends_at whithin each of which the value does not change, i.e.
length(unique(x[starts_at:ends_at])) == 1L is TRUE.
findChanges(x)findChanges(x)
x |
vector of atomic mode (e.g. logical, numeric, character) |
The input vector x must not contain any NA because it is not
clear how to handle this. The function stops with an error if there are any
NA in x.
data frame with one row more than there are value changes in
x. If the value in x does not change from one index to the
next, it is assumed to belong to the same index region. If the value
changes, a new index region begins. In the result data frame each index
region is given by starts_at and ends_at which are the
indices of the first and last element, respectively, of each index region.
The function returns NULL for input vectors x of length 0.
findChanges(c(1,2,2,3,3,3)) findChanges(c("a", "a", "b", "c", "c", "d")) findChanges(c(TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE))findChanges(c(1,2,2,3,3,3)) findChanges(c("a", "a", "b", "c", "c", "d")) findChanges(c(TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE))
Find Rows in a data frame that are identical in the key columns but not identical in all columns
findPartialDuplicates(data, key_columns, skip_columns = NULL)findPartialDuplicates(data, key_columns, skip_columns = NULL)
data |
data frame |
key_columns |
names of columns in |
skip_columns |
names of columns to be skipped when looking for duplicated rows |
NULL if there are no rows in data that have identical
values in the key_columns or if all groups of rows that have
identical values in the key_columns are also identical in all the
other columns (except for those named in skip_columns). Otherwise
a list is returned with the one element per duplicate in the key columns.
The list elements are subsets of data representing the rows of
data that are identical in the key columns but different in at least
one of the other columns.
findPartialDuplicates(key_columns = "id", data = rbind( data.frame(id = 1, value = 1), data.frame(id = 2, value = 2), data.frame(id = 2, value = 3), data.frame(id = 3, value = 3), data.frame(id = 3, value = 3), data.frame(id = 3, value = 3.1) ))findPartialDuplicates(key_columns = "id", data = rbind( data.frame(id = 1, value = 1), data.frame(id = 2, value = 2), data.frame(id = 2, value = 3), data.frame(id = 3, value = 3), data.frame(id = 3, value = 3), data.frame(id = 3, value = 3.1) ))
Close the PDF device (default: dev.cur()) and open the PDF file in a
PDF viewer
finishAndShowPdf(PDF, which = grDevices::dev.cur(), ...)finishAndShowPdf(PDF, which = grDevices::dev.cur(), ...)
PDF |
full path to the PDF file to be opened in the PDF Viewer |
which |
passed to |
... |
further arguments passed to |
Finish and Display PDF File if Condition is Met
finishAndShowPdfIf(to.pdf, PDF, ...)finishAndShowPdfIf(to.pdf, PDF, ...)
to.pdf |
if |
PDF |
path to the opened pdf file |
... |
arguments passed to |
Returns the first element using the function head
firstElement(x)firstElement(x)
x |
object |
first element: x[1]
data/time column of data frame
firstPosixColumn(x)firstPosixColumn(x)
x |
data frame in which to find a column of class "POSIXt" |
French Unicode Letter to ASCII Letter(s)
frenchToAscii()frenchToAscii()
list of ASCII characters (list elements) replacing unicode characters (element names)
Counts the number of occurrences of the different values in each column of a data frame
frequencyTable( data, columns = names(data), orderByLeastLevels = TRUE, as.data.frame = TRUE, useNA = c("no", "ifany", "always")[2] )frequencyTable( data, columns = names(data), orderByLeastLevels = TRUE, as.data.frame = TRUE, useNA = c("no", "ifany", "always")[2] )
data |
data frame |
columns |
columns of |
orderByLeastLevels |
if TRUE (default) the list elements in the output
list each of which represents one column of |
as.data.frame |
if TRUE (default) the result is a data frame, otherwise a list (see below) |
useNA |
passed to |
for as.data.frame = FALSE a list of data frames each of which
represents the frequency statistics for one column of data. Each
data frame has columns column (name of the column of data),
value (value occurring in column of data),
count (number of occurrences). For as.data.frame = TRUE one
data frame being the result of rbind-ing together these data frames.
# Some example data (data <- data.frame( A = c("a1", "a2", "a1", "a1", "a2", "", "a2", NA, "a1"), B = c("b1", "b1", NA, "b2", "b2", "b1", " ", "b3", "b2") )) frequencyTable(data) # results in a data frame frequencyTable(data, as.data.frame = FALSE) # results in a list# Some example data (data <- data.frame( A = c("a1", "a2", "a1", "a1", "a2", "", "a2", NA, "a1"), B = c("b1", "b1", NA, "b2", "b2", "b1", " ", "b3", "b2") )) frequencyTable(data) # results in a data frame frequencyTable(data, as.data.frame = FALSE) # results in a list
Expanded file path with backslashes (each duplicated if
doubleBackslashes is TRUE). Duplicated backslashes can be
useful when being used in RMarkdown documents
fullWinPath(x, doubleBackslashes = FALSE)fullWinPath(x, doubleBackslashes = FALSE)
x |
file path (with slashes or backslashes as separators) |
doubleBackslashes |
if |
Windows compatible file path with backslashes (duplicated if
doubeBackslashes is TRUE)
cat(fullWinPath("~/a/b")) cat(fullWinPath("~/a/b", doubleBackslashes = TRUE))cat(fullWinPath("~/a/b")) cat(fullWinPath("~/a/b", doubleBackslashes = TRUE))
Sort a Data Frame by all of its Columns
fullySorted(x, decreasing = FALSE, ..., renumber.rows = TRUE)fullySorted(x, decreasing = FALSE, ..., renumber.rows = TRUE)
x |
data frame |
decreasing |
passed to |
... |
further arguments passed to |
renumber.rows |
if |
fullySorted(head(iris)) fullySorted(head(iris), decreasing = TRUE) fullySorted(head(iris[, 5:1])) fullySorted(head(iris[, 5:1]), decreasing = TRUE)fullySorted(head(iris)) fullySorted(head(iris), decreasing = TRUE) fullySorted(head(iris[, 5:1])) fullySorted(head(iris[, 5:1]), decreasing = TRUE)
Generate a Decryption Key File
generateKeyFile(target)generateKeyFile(target)
target |
full path to the file to which the key shall be written |
createPasswordFile, getPassword
Get File Path of User's Home Directory
get_homedir(osType = .OStype())get_homedir(osType = .OStype())
osType |
Optional. Type of operating system, one of |
path of user's home directory on windows (full path home directory path but without '/Documents') or linux
Safely get the attribute of an object. An error is given if the attribute does not exist (and do.stop = TRUE)
getAttribute(x, attributeName, do.stop = TRUE)getAttribute(x, attributeName, do.stop = TRUE)
x |
object from which to take the attribute |
attributeName |
name of the attribute to be returned |
do.stop |
if |
x <- structure(1, a = 2) # getAttribute(x, "b") # gives a clear error message identical(getAttribute(x, "a"), attr(x, "a")) # is TRUE # Get an attribute's attribute by means of a "path" notation y <- structure(1, a = structure(2, b = 3)) z <- structure(4, y = y) str(y) str(z) kwb.utils::getAttribute(y, "a/b") kwb.utils::getAttribute(z, "y/a/b")x <- structure(1, a = 2) # getAttribute(x, "b") # gives a clear error message identical(getAttribute(x, "a"), attr(x, "a")) # is TRUE # Get an attribute's attribute by means of a "path" notation y <- structure(1, a = structure(2, b = 3)) z <- structure(4, y = y) str(y) str(z) kwb.utils::getAttribute(y, "a/b") kwb.utils::getAttribute(z, "y/a/b")
Get element from vector, counting from head or tail
getByPositiveOrNegativeIndex(elements, index)getByPositiveOrNegativeIndex(elements, index)
elements |
vector of elements |
index |
positive or negative index(es) with absolute value between 1 and length(elements) |
element(s) out of elements corresponding to the index(es) given in index
Get the Lenghts of List Elements
getElementLengths(x)getElementLengths(x)
x |
a list |
vector of integer
x <- list(a = 1:3, b = list(x = 1, y = 2), c = 1:100) getElementLengths(x)x <- list(a = 1:3, b = list(x = 1, y = 2), c = 1:100) getElementLengths(x)
Get even Numbers out of a Vector of Integers
getEvenNumbers(x)getEvenNumbers(x)
x |
vector of integer |
Take the function value or a default value if the function value is NA
getFunctionValueOrDefault(values, FUN, default, warningMessage = NA)getFunctionValueOrDefault(values, FUN, default, warningMessage = NA)
values |
vector of values given to |
FUN |
function to which values are passed and which offers the argument "na.rm" |
default |
default value to be returned if all values are NA |
warningMessage |
Warning message given if the default was taken |
gat variable from .GlobalEnv
getGlobally(x, default = NULL, create.if.not.existing = TRUE)getGlobally(x, default = NULL, create.if.not.existing = TRUE)
x |
name of variable |
default |
default value to which the variable is assigned (if create.if.not.existing = TRUE) in case that it does not yet exist. Default: NULL |
create.if.not.existing |
if TRUE and if the variable does not yet exist,
it is created and initialised with the value given in |
Localise Keywords in Data Frame
getKeywordPositions(dataFrame, keywords, asDataFrame = TRUE)getKeywordPositions(dataFrame, keywords, asDataFrame = TRUE)
dataFrame |
data frame or matrix in which to search for given keywords |
keywords |
(list of) keywords to be looked for in data frame |
asDataFrame |
if TRUE (default), a data frame is returned, otherwise a matrix |
data frame (if asDataFrame = TRUE) or matrix with one column per keyword that was given in keywords. The first row contains the row numbers and the second row contains the column numbers, respectively, of the fields in dataFrame in which the corresponding keywords were found.
This function allows to access a list element of a nested list structure with a "path". The path "a/b/c", for example, applied to a list L refers to list element L[["a"]][["b"]][["c"]] (same as L[[c("a", "b", "c")]]).
getListNode(x, path)getListNode(x, path)
x |
a list |
path |
"path" to list element in the form <key1>/<key2>/<key3>... |
L <- list( a1 = list( b1 = list(c = 1, d = 2, e = 3), b2 = list(c = list(c1 = 1, c2 = 2, c3 = 3)) ), a2 = list(b3 = 22, b4 = 44) ) getListNode(L, "a1/b2/c/c2") getListNode(L, "a1/b2/c") getListNode(L, "a2/b3")L <- list( a1 = list( b1 = list(c = 1, d = 2, e = 3), b2 = list(c = list(c1 = 1, c2 = 2, c3 = 3)) ), a2 = list(b3 = 22, b4 = 44) ) getListNode(L, "a1/b2/c/c2") getListNode(L, "a1/b2/c") getListNode(L, "a2/b3")
listObjects instead.Deprecated. Use listObjects instead.
getNamesOfObjectsInRDataFiles(files.rdata)getNamesOfObjectsInRDataFiles(files.rdata)
files.rdata |
vector of full paths to .RData files |
loadObject instead.Deprecated. Please use loadObject instead.
getObjectFromRDataFile(file, objectname = NULL, dbg = TRUE)getObjectFromRDataFile(file, objectname = NULL, dbg = TRUE)
file |
path to .RData file |
objectname |
name of object to be loaded |
dbg |
if |
R object as specified in objectname. If an object of that name does not exist in the .RData file an error is thrown
Get odd Numbers out of a Vector of Integers
getOddNumbers(x)getOddNumbers(x)
x |
vector of integer |
Given the path to a file containing an encrypted password and given the path to the file containing the key that was used to do the encryption this function returns the original password, invisibly.
getPassword(passwordFile, keyFile)getPassword(passwordFile, keyFile)
passwordFile |
path to the password file, as generated by
|
keyFile |
path to the key file, as generated by
|
The password (character) or NA if no password is stored, both
invisibly.
generateKeyFile, createPasswordFile
Get Paths and String Values from Recursive List
getPathsAndValuesFromRecursiveList(x, path = "")getPathsAndValuesFromRecursiveList(x, path = "")
x |
a list |
path |
start path |
data frame with columns path and value. The
data frame contains all non-list elements that are contained in x,
coerced to character, in column value, together with the sequence of
element names "leading" to the value when starting at x. For example,
the path to element x$a$a1 is /a/a1 (see example).
# Define a recursive list x <- list( a = list(a1 = "A1", a2 = "A2"), b = list(b1 = "B1", b2 = "B2", b3 = "B3"), c = list(c1 = list(c11 = "C11"), c2 = list(c21 = "C21", c22 = "C22")) ) # Get all non-list-elements and their "path" as a data frame getPathsAndValuesFromRecursiveList(x)# Define a recursive list x <- list( a = list(a1 = "A1", a2 = "A2"), b = list(b1 = "B1", b2 = "B2", b3 = "B3"), c = list(c1 = list(c11 = "C11"), c2 = list(c21 = "C21", c22 = "C22")) ) # Get all non-list-elements and their "path" as a data frame getPathsAndValuesFromRecursiveList(x)
Return tags of the form <tag> that are contained in the string x.
getTagNames(x, bt = c("<>", "[]")[1], dbg = FALSE, expected.length = length(x))getTagNames(x, bt = c("<>", "[]")[1], dbg = FALSE, expected.length = length(x))
x |
vector of character |
bt |
bracket type, must be one of c("<>", "[]"). Default: "<>" |
dbg |
if |
expected.length |
if given and different from the length of |
Guess Column Separator Used in File
guessSeparator(csvFile, n = 10, separators = c(";", ",", "\t"))guessSeparator(csvFile, n = 10, separators = c(";", ",", "\t"))
csvFile |
full path to text file containing 'comma separated values' |
n |
number of first lines in the file to be looked at |
separators |
vector of possible column separator characters the file is to be checked for |
Guess Column Separator (Version 1)
guessSeparator.1(textlines, separators, comment.char = "#")guessSeparator.1(textlines, separators, comment.char = "#")
textlines |
vector of character representing the first lines of a file |
separators |
vector of possible column separator characters the file is to be checked for |
comment.char |
comment character |
Guess Column Separator (Version 2)
guessSeparator.2(textlines, separators)guessSeparator.2(textlines, separators)
textlines |
vector of character representing the first lines of a file |
separators |
vector of possible column separator characters the file is to be checked for |
Does a String End with Slash?
hasFinalSlash(x)hasFinalSlash(x)
x |
vector of character |
vector of boolean being TRUE at indices where the elements in
x end with a slash ("/")
(is_directory <- hasFinalSlash(c("a", "b/", "c", "d/")))(is_directory <- hasFinalSlash(c("a", "b/", "c", "d/")))
This is just a "shortcut" to "length(x) == 0L"
hasZeroLength(x)hasZeroLength(x)
x |
R object that has a length attribute, e.g. vector or list |
TRUE if length(x) == 0L, otherwise FALSE
hasZeroLength(character()) # TRUE hasZeroLength(list()) # TRUE # Do not confuse, has nothing to do with the length of a string # here: vector of length one hasZeroLength("") # FALSE # Remember that the length of a data frame is the number of its columns hasZeroLength(data.frame(a = character())) # FALSEhasZeroLength(character()) # TRUE hasZeroLength(list()) # TRUE # Do not confuse, has nothing to do with the length of a string # here: vector of length one hasZeroLength("") # FALSE # Remember that the length of a data frame is the number of its columns hasZeroLength(data.frame(a = character())) # FALSE
Print the first and last rows of a data frame using head and tail, respectively. Print the number of omitted rows
headtail(x, n = 6, pattern = "[%d rows omitted]")headtail(x, n = 6, pattern = "[%d rows omitted]")
x |
data frame |
n |
total number of rows to be printed. |
pattern |
pattern given to |
number of omitted rows, invisibly
x <- data.frame(number = 1:26, letter = LETTERS) headtail(x) headtail(x, 10) headtail(x, 16) headtail(x[10:20, ], 10)x <- data.frame(number = 1:26, letter = LETTERS) headtail(x) headtail(x, 10) headtail(x, 16) headtail(x[10:20, ], 10)
Adds missing columns to the given data frame so that the resulting data frame contains all columns given in the vector colNames. Added columns are filled with NA values.
hsAddMissingCols(dataFrame, colNames, fill.value = NA)hsAddMissingCols(dataFrame, colNames, fill.value = NA)
dataFrame |
data frame to which column names are to be appended |
colNames |
vector containing names of columns that shall be contained in dataFrame |
fill.value |
value to be inserted into newly created columns. Default:
|
data frame with columns as listed in colNames
Conversion of text representing a number to a valid number
hsChrToNum(x, country, stopOnError = TRUE)hsChrToNum(x, country, stopOnError = TRUE)
x |
(vector of) text value(s) to be converted to numeric |
country |
"en" if value(s) in x is (are) given in English format (decimal point ".", thousands separator ",") or "de" if value is given in German format (decimal point ",", thousands separator "."). |
stopOnError |
if TRUE (default) the program stops if any of the given values could not be converted. |
vector of numeric(s). In case of conversion the function stops (if
stopOnError = TRUE) or returns NA for those indices for which
the conversion failed. In the latter case an attribute "errorIndices"
containing the corresponding indices is assigned to the result vector.
Count occurrences of chr in str
hsCountInStr(chr, str)hsCountInStr(chr, str)
chr |
character string (or pattern) to be looked for and counted in
|
str |
character string in which to count for |
number of occurrences of char in str
Returns data frame in which all empty columns (NA in all rows) are removed
hsDelEmptyCols(dataFrame, FUN = function(x) all(is.na(x)), drop = FALSE)hsDelEmptyCols(dataFrame, FUN = function(x) all(is.na(x)), drop = FALSE)
dataFrame |
data frame of which empty columns (NA in all rows) are to be removed |
FUN |
function to be applied to each column to decide whether the column
is empty or not. Default: |
drop |
if |
copy of input data frame but with all empty columns removed
Converts a data frame in "matrix form" to a data frame in "list form"
hsMatrixToListForm( df, keyFields, parFields = setdiff(names(df), keyFields), colNamePar = "parName", colNameVal = "parVal", stringsAsFactors = FALSE )hsMatrixToListForm( df, keyFields, parFields = setdiff(names(df), keyFields), colNamePar = "parName", colNameVal = "parVal", stringsAsFactors = FALSE )
df |
data frame |
keyFields |
names of key fields (e.g. date/time) |
parFields |
names of fields representing differen parameters. Default: column names that are not in keyFields |
colNamePar |
name of column in result data frame that will contain the parameter names |
colNameVal |
name of column in result data frame that will contain the parameter values |
stringsAsFactors |
if TRUE, columns of type character in the result data frame are converted to factors. Parameter is passed to cbind, rbind. |
data frame in "list form" (long format)
Calculate moving mean of n values "around" values
hsMovingMean(x, n, na.rm = FALSE)hsMovingMean(x, n, na.rm = FALSE)
x |
vector of values of which moving mean is to be calculated |
n |
number of values "around" the values in x, including the values in x, of which the mean is calculated. Only odd numbers 1, 3, 5, ... allowed. For each x[i] in x the moving mean is calculated by: (x[i-(n-1)/2] + ... + x[i-1] + x[i] + x[i+1] + ... + x[i+(n-1)/2]) / n |
na.rm |
logical. Should missing values (including NaN) be omitted from the calculations? |
Vector of moving means with the same number of values as there are in x. If na.rm is FALSE, the first (n-1)/2 values and the last (n-1)/2 values are NA since there are not enough values at the start and the end of the vector to calculate the mean.
x <- rnorm(30) plot(x, type = "b", main = "Moving mean over 3, 5, 7 points") times <- 2:4 for (i in times) { lines(hsMovingMean(x, n = 2*i - 1), col = i, type = "b", lwd = 2) } legend("topright", fill = times, legend = sprintf("n = %d", 2*times - 1))x <- rnorm(30) plot(x, type = "b", main = "Moving mean over 3, 5, 7 points") times <- 2:4 for (i in times) { lines(hsMovingMean(x, n = 2*i - 1), col = i, type = "b", lwd = 2) } legend("topright", fill = times, legend = sprintf("n = %d", 2*times - 1))
Open Windows Explorer
hsOpenWindowsExplorer( startdir = tempdir(), use.shell.exec = !isNetworkPath(startdir) )hsOpenWindowsExplorer( startdir = tempdir(), use.shell.exec = !isNetworkPath(startdir) )
startdir |
directory to be opened in Windows Explorer |
use.shell.exec |
if |
Deprecated. Please use preparePdf instead.
hsPrepPdf( strPdf = tempfile(fileext = ".pdf"), boolLandscape = TRUE, bordW = 2, bordH = 2, makeCur = TRUE, ... )hsPrepPdf( strPdf = tempfile(fileext = ".pdf"), boolLandscape = TRUE, bordW = 2, bordH = 2, makeCur = TRUE, ... )
strPdf |
see argument |
boolLandscape |
see argument |
bordW |
see argument |
bordH |
see argument |
makeCur |
see argument |
... |
see ... in |
quotes objects of type character with quoting character
hsQuoteChr(x, qchar = "'", escapeMethod = c("double", "backslash", "none"))hsQuoteChr(x, qchar = "'", escapeMethod = c("double", "backslash", "none"))
x |
vector or list of character strings |
qchar |
quoting character to be used. Default: single quote "'" |
escapeMethod |
one of |
Rename Columns in a Data Frame (deprecated, use renameColumns instead)
hsRenameColumns(dframe, renames)hsRenameColumns(dframe, renames)
dframe |
data.frame |
renames |
list with named elements each of which defines a column rename in the form <old-name> = <new-name> |
Resolve strings according to substitutions defined in dictionary
hsResolve(x, dict = NULL, ..., dbg = FALSE)hsResolve(x, dict = NULL, ..., dbg = FALSE)
x |
(vector of) string expression(s) to be resolved using the dictionary
|
dict |
dictionary: list with named elements where the element name represents the key and the element value represents the value assigned to the key. |
... |
additional named arguments that are added to |
dbg |
if |
The (resolved) value is returned
Restore given attributes that are not object attributes any more
hsRestoreAttributes(x, attribs)hsRestoreAttributes(x, attribs)
x |
object |
attribs |
former attributes of x (as retrieved by attributes(x)) to be restored |
Returns a name that is not yet contained in a vector myNames of existing names.
hsSafeName(myName, myNames)hsSafeName(myName, myNames)
myName |
desired name. |
myNames |
vector of existing names. |
If myName is not contained in myNames it is returned. Otherwise myName is modified to myName_01, myName_02, ... until a non-existing name is found that is then returned.
existing <- c("a", "b") myName <- hsSafeName("c", existing) myName # "c" myName <- hsSafeName("a", existing) myName # "a_1" hsSafeName("a", c(existing, myName)) # "a_2"existing <- c("a", "b") myName <- hsSafeName("c", existing) myName # "c" myName <- hsSafeName("a", existing) myName # "a_1" hsSafeName("a", c(existing, myName)) # "a_2"
Wrapper around "shell"
hsShell(commandLine, ...)hsShell(commandLine, ...)
commandLine |
character string passed to |
... |
additional arguments passed to |
Opens the PDF file of which the full path is given in Pdf in a PDF viewer.
hsShowPdf(Pdf, dbg = TRUE)hsShowPdf(Pdf, dbg = TRUE)
Pdf |
full path to PDF file |
dbg |
if |
# Set path to PDF file and open PDF device tmpPdf <- tempfile("ex_hsFinishPdf", fileext = ".pdf") preparePdf(tmpPdf) # Plot something plot(x <- seq(-pi,pi,pi/100), sin(x), type = "l") # Finish PDF file. grDevices::dev.off() ## Not run: # Open PDF file in viewer. hsShowPdf(tmpPdf) ## End(Not run)# Set path to PDF file and open PDF device tmpPdf <- tempfile("ex_hsFinishPdf", fileext = ".pdf") preparePdf(tmpPdf) # Plot something plot(x <- seq(-pi,pi,pi/100), sin(x), type = "l") # Finish PDF file. grDevices::dev.off() ## Not run: # Open PDF file in viewer. hsShowPdf(tmpPdf) ## End(Not run)
Convert date string to string and stop on failure
hsStringToDate(strDate, dateFormat)hsStringToDate(strDate, dateFormat)
strDate |
(vector of) string(s) representing date(s) |
dateFormat |
date format specifier describing the format in which dates
are represented in the csv file. Use placeholders , |
(vector of) Date object(s)
Convert string to double considering given decimal sign in input string
hsStringToDouble(strDbl, dec = ".")hsStringToDouble(strDbl, dec = ".")
strDbl |
character string representing a double value |
dec |
decimal character (default: |
double representation of input string strDbl
substSpecialChars instead.Deprecated. Use substSpecialChars instead.
hsSubstSpecChars(x)hsSubstSpecChars(x)
x |
string containing special characters to be substituted |
input string x with special characters being substituted by a meaningful represenation or underscore, multiple underscores replaced by a single underscore and multiple underscores at the end removed.
Wrapper around "system"
hsSystem(commandLine, ...)hsSystem(commandLine, ...)
commandLine |
character string passed to |
... |
additional arguments passed to |
Remove leading, trailing (and, if requested, duplicate) spaces
hsTrim(str, trim.multiple.spaces = TRUE, dbg = FALSE)hsTrim(str, trim.multiple.spaces = TRUE, dbg = FALSE)
str |
vector of character containing the strings to be trimmed |
trim.multiple.spaces |
if TRUE (default), multiple consecutive spaces are replaced by one space |
dbg |
if |
input string str without leading or trailing spaces and with multiple consecutive spaces being replaced by a single space
Returns TRUE if text representation of number is in correct format in terms of decimal character and (optionally) thousand's separator character.
hsValidValue(x, lng, dbg = FALSE, accept.na = TRUE)hsValidValue(x, lng, dbg = FALSE, accept.na = TRUE)
x |
vector of character strings |
lng |
language code: "en" for English or "de" for German |
dbg |
if |
accept.na |
if |
Indentat a String (Add Spaces to the Left)
indent(x, depth = 0L, tabLength = 2L)indent(x, depth = 0L, tabLength = 2L)
x |
vector of character |
depth |
indentation level. Default: 0 |
tabLength |
number of spaces per indentation level. Default: 2 |
check for values within minimum and maximum value
inRange(values, min.value, max.value, rng = NULL)inRange(values, min.value, max.value, rng = NULL)
values |
vector of values |
min.value |
minimum value (inclusive) |
max.value |
maximum value (inclusive) |
rng |
optional. Vector of two elements representing |
vector of boolean
Insert one or more new columns into a data frame before or after the given column
insertColumns( Data, ..., before = "", after = "", stringsAsFactors = defaultIfNULL(options()$stringsAsFactors, FALSE) )insertColumns( Data, ..., before = "", after = "", stringsAsFactors = defaultIfNULL(options()$stringsAsFactors, FALSE) )
Data |
data frame |
... |
named objects each of which will be a new column in the data frame. Each object must have as many elements as Data has rows. |
before |
name of column before which to insert the new column(s) |
after |
name of column after which to insert the new column(s) |
stringsAsFactors |
passed on to data.frame() and cbind() |
data frame Data with new columns inserted before the column
named as given in before or after the column named as given in
after
Data <- data.frame(A = 1:5, B = 2:6) # Insert new columns X and Y before column "B" insertColumns(Data, before = "B", X = paste0("x", 1:5), Y = paste0("y", 1:5)) # This is the same as inserting new columns X and Y after column "A": insertColumns(Data, after = "A", X = paste0("x", 1:5), Y = paste0("y", 1:5)) # You may also insert before the first... insertColumns(Data, before = "A", X = paste0("x", 1:5), Y = paste0("y", 1:5)) # ... or after the last column insertColumns(Data, after = "B", X = paste0("x", 1:5), Y = paste0("y", 1:5))Data <- data.frame(A = 1:5, B = 2:6) # Insert new columns X and Y before column "B" insertColumns(Data, before = "B", X = paste0("x", 1:5), Y = paste0("y", 1:5)) # This is the same as inserting new columns X and Y after column "A": insertColumns(Data, after = "A", X = paste0("x", 1:5), Y = paste0("y", 1:5)) # You may also insert before the first... insertColumns(Data, before = "A", X = paste0("x", 1:5), Y = paste0("y", 1:5)) # ... or after the last column insertColumns(Data, after = "B", X = paste0("x", 1:5), Y = paste0("y", 1:5))
Convert Integers to Numeral System
intToNumeralSystem(x, base)intToNumeralSystem(x, base)
x |
vector of integers |
base |
base of the numeral system |
matrix with as many rows as there are elements in x and as
many columns as digits that are required to represent the integers in
x in the numeral system in base base. The elements of
x appear as row names whereas the powers of base appear as
column names.
intToNumeralSystem(1:16, base = 2) # binary system intToNumeralSystem(1:16, base = 10) # decimal system intToNumeralSystem(1:16, base = 8) # octal systemintToNumeralSystem(1:16, base = 2) # binary system intToNumeralSystem(1:16, base = 10) # decimal system intToNumeralSystem(1:16, base = 8) # octal system
returns a vector of logical as long as x holding TRUE at indices where the list element at the same indices are named and FALSE at positions where the list element at the same indices are not named.
is.unnamed(x)is.unnamed(x)
x |
list |
vector of logical
is.unnamed(list(1, b = 2)) # TRUE FALSE is.unnamed(list(a = 1, 2)) # FALSE TRUE is.unnamed(list()) # logical(0) is.unnamed(list(a = 1, 2, c = 3)) # FALSE TRUE FALSEis.unnamed(list(1, b = 2)) # TRUE FALSE is.unnamed(list(a = 1, 2)) # FALSE TRUE is.unnamed(list()) # logical(0) is.unnamed(list(a = 1, 2, c = 3)) # FALSE TRUE FALSE
The code has been "stolen" from showNonASCII
isASCII(x)isASCII(x)
x |
vector of character |
vector of logical with TRUE at positions i where
x[i] contains only ASCII characters
months <- c("Januar", "Februar", "M\ue4rz") cat(months, "\n") isASCII(months)months <- c("Januar", "Februar", "M\ue4rz") cat(months, "\n") isASCII(months)
Does a string end with one or two dots (".", "..")?
isDotOrDoubleDot(x)isDotOrDoubleDot(x)
x |
vector of character |
vector of logical
isDotOrDoubleDot(c("a", "b.", "c..", "d", "efg..h"))isDotOrDoubleDot(c("a", "b.", "c..", "d", "efg..h"))
Check for Even Numbers
isEvenNumber(x)isEvenNumber(x)
x |
vector of numeric |
Check whether a script has been loaded (with source) or not. The information
is read from a list that stores a logical value (TRUE or FALSE)
for each script name for which setLoaded has been called.
isLoaded(scriptName)isLoaded(scriptName)
scriptName |
name of the script for which to get the "loaded" state |
setLoaded (see example there)
# For an example see kwb.utils::setLoaded()... # In fact, the information about loaded scripts is stored in the # R option "kwb.utils.loaded": setLoaded("myScript") options("kwb.utils.loaded")[[1]]# For an example see kwb.utils::setLoaded()... # In fact, the information about loaded scripts is stored in the # R option "kwb.utils.loaded": setLoaded("myScript") options("kwb.utils.loaded")[[1]]
isNaInAllColumns
isNaInAllColumns(dataFrame)isNaInAllColumns(dataFrame)
dataFrame |
data frame or matrix |
logical vector with as many elements as there are rows in dataFrame (TRUE for rows in which all elements are NA, FALSE for rows in which there is at least one non-NA element).
isNaInAllRows
isNaInAllRows(dataFrame)isNaInAllRows(dataFrame)
dataFrame |
data frame or matrix |
logical vector with as many elements as there are columns in dataFrame (TRUE for columns in which all elements are NA, FALSE for columns in which there is at least one non-NA element).
is an object NA or equal to the empty string "" (after trimming)?
isNaOrEmpty(x)isNaOrEmpty(x)
x |
object to be tested for NA or being empty (equal to "", after trimming) |
(vector of) logical, being TRUE for each element in x that is NA or the empty string "" (after trimming)
Does the Path Represent a Network Path?
isNetworkPath(x)isNetworkPath(x)
x |
vector of character representing paths |
isNetworkPath("//server/folder/file.txt")isNetworkPath("//server/folder/file.txt")
isNullOrEmpty
isNullOrEmpty(x)isNullOrEmpty(x)
x |
object to be tested for NULL or being empty (vector or list of length 0 or data frame with no rows) |
TRUE if x is NULL or x is a vector of length 0 or x is a data frame with no rows.
Check for Odd Numbers
isOddNumber(x)isOddNumber(x)
x |
vector of numeric |
Does an Object Inherit from "try-error"?
isTryError(x)isTryError(x)
x |
R object |
logical of length one, TRUE if x inherits from "try-error",
otherwise FALSE
result <- try(stop("Stop!"), silent = TRUE) isTryError(result) # TRUEresult <- try(stop("Stop!"), silent = TRUE) isTryError(result) # TRUE
Returns the last element using the function tail
lastElement(x)lastElement(x)
x |
object |
The last element of object is returned: x[[length(x)]]
if x is a list (and not a data frame), otherwise tail(x, 1).
Left Part of a String
left(x, n)left(x, n)
x |
vector of character |
n |
number of characters to be kept from the beginning of each character
string within |
vector of character
left("Good Morning", 4)left("Good Morning", 4)
TODO: Simply use startsWith?
leftSubstringEquals(x, y)leftSubstringEquals(x, y)
x |
String of which the left part is compared with |
y |
String to be compared with the left part of |
leftSubstringEquals("Great job", "Great") leftSubstringEquals("Great car", "Great") leftSubstringEquals("Boring job", "Great")leftSubstringEquals("Great job", "Great") leftSubstringEquals("Great car", "Great") leftSubstringEquals("Boring job", "Great")
limit the values in x so that each value lies within the closed
interval [left, right]
limitToRange(x, left = .Machine$double.eps, right = 1)limitToRange(x, left = .Machine$double.eps, right = 1)
x |
vector of numeric values |
left |
lower boundary |
right |
upper boundary |
limitToRange(1:20, left = 5, right = 15)limitToRange(1:20, left = 5, right = 15)
Calculate the linear combination of a matrix
linearCombination(x, coeffs, version = 1)linearCombination(x, coeffs, version = 1)
x |
numeric matrix |
coeffs |
numeric vector of coefficients |
version |
1 or 2 (default: 1). Allows for two different versions of calculation both of which should return the same! |
(x <- randomMatrix(c(4, 2))) (coeffs <- rnorm(ncol(x))) # Calculate the linear combination manually LC1 <- x[, 1] * coeffs[1] + x[, 2] * coeffs[2] # Caluclate with linearCombination() LC2 <- linearCombination(x, coeffs) # The result shoulc be the same! all.equal(LC1, LC2) # TRUE(x <- randomMatrix(c(4, 2))) (coeffs <- rnorm(ncol(x))) # Calculate the linear combination manually LC1 <- x[, 1] * coeffs[1] + x[, 2] * coeffs[2] # Caluclate with linearCombination() LC2 <- linearCombination(x, coeffs) # The result shoulc be the same! all.equal(LC1, LC2) # TRUE
Get Names of Objects in .RData files
listObjects(files)listObjects(files)
files |
vector of full paths to .RData files |
## Not run ## Search for available .RData files below "searchdir" #searchdir <- "Y:/SUW_Department/Projects/SEMA/WP/20_Braunschweig" #files <- dir(searchdir, pattern = "\\.RData$", recursive = TRUE, full.names = TRUE) ## Get the names of the objects in the .RData files #objectsInFiles <- listObjects(files) ## Which file contains the object "DataQ"? #dataQ.found <- sapply(objectsInFiles, function(x) {"DataQ" %in% x}) #cat("DataQ was found in the following files:", # paste(files[dataQ.found], collapse = "\n "))## Not run ## Search for available .RData files below "searchdir" #searchdir <- "Y:/SUW_Department/Projects/SEMA/WP/20_Braunschweig" #files <- dir(searchdir, pattern = "\\.RData$", recursive = TRUE, full.names = TRUE) ## Get the names of the objects in the .RData files #objectsInFiles <- listObjects(files) ## Which file contains the object "DataQ"? #dataQ.found <- sapply(objectsInFiles, function(x) {"DataQ" %in% x}) #cat("DataQ was found in the following files:", # paste(files[dataQ.found], collapse = "\n "))
List Elements Recursively up to Depth
listToDepth( path, max_depth = 0L, full_info = FALSE, FUN = listFiles, ..., depth = 0, prob_mutate = 0, template = NULL )listToDepth( path, max_depth = 0L, full_info = FALSE, FUN = listFiles, ..., depth = 0, prob_mutate = 0, template = NULL )
path |
path to the element at which to start listing |
max_depth |
maximal depth level of which to list elements. A value of
|
full_info |
return only |
FUN |
function called to get the listing of the element given in
|
... |
further arguments passed to |
depth |
start depth of recursion if |
prob_mutate |
probability to alter the path so that it becomes useless. This is zero by default. Set the value only if you want to test how the function behaves if the listing of a path fails. |
template |
empty data frame (zero rows) and with columns that are
identical to the columns in the data frame returned by |
data frame containing at least the columns file and
isdir. If full_info = TRUE the result data frame may contain
further columns, as provided by the function given in FUN for
full_info = TRUE.
# Example list function provided in this package (file listing) FUN <- kwb.utils:::listFiles # The list function must provide empty records when no path is given. The # returned data frame must provide the columns "file" and "isdir" ... FUN() FUN(full_info = TRUE) # ... even when being called with an empty character vector FUN(character()) FUN(character(), full_info = TRUE) # Call the function recursively up to the given depth level kwb.utils:::listToDepth(".", max_depth = 1, FUN = FUN)# Example list function provided in this package (file listing) FUN <- kwb.utils:::listFiles # The list function must provide empty records when no path is given. The # returned data frame must provide the columns "file" and "isdir" ... FUN() FUN(full_info = TRUE) # ... even when being called with an empty character vector FUN(character()) FUN(character(), full_info = TRUE) # Call the function recursively up to the given depth level kwb.utils:::listToDepth(".", max_depth = 1, FUN = FUN)
This function parses R scripts at the given paths and provides all objects in an environment that is attached to the search path.
loadFunctions(paths, attach = TRUE, name = "kwb", dbg = TRUE)loadFunctions(paths, attach = TRUE, name = "kwb", dbg = TRUE)
paths |
vector of character with paths to files (R scripts) or directories (in which to look for R scripts). |
attach |
if |
name |
name that is used when attaching the environment with all parsed objects to the search path. Default: kwb |
dbg |
logical indicating whether or not to show debug messages |
if attach is FALSE the environment with all parsed
objects is returned, otherwise NULL, invisibly.
Load an R object of given name from a .RData file
loadObject(file, objectname = NULL, dbg = TRUE)loadObject(file, objectname = NULL, dbg = TRUE)
file |
path to .RData file |
objectname |
name of object to be loaded |
dbg |
if |
R object as specified in objectname. If an object of that name does not exist in the .RData file an error is thrown
Returns the first element of what class(x) returns
mainClass(x)mainClass(x)
x |
any R object |
name of main class of x (vector of character of length one)
class(as.POSIXct("2022-06-02")) mainClass(as.POSIXct("2022-06-02"))class(as.POSIXct("2022-06-02")) mainClass(as.POSIXct("2022-06-02"))
Make Duplicated Character Strings Unique
adds ".1", ".2", etc. to duplicate values
makeUnique(x, warn = TRUE, sep = ".", simple = FALSE)makeUnique(x, warn = TRUE, sep = ".", simple = FALSE)
x |
vector of character strings |
warn |
if |
sep |
separator between name and suffix number. Default: "." |
simple |
if |
x with duplicate elements being modified to "element.1",
"element.2", etc.
are data frame rows matching given criteria?
matchesCriteria( Data, criteria = NULL, na.to.false = FALSE, add.details = FALSE, dbg = TRUE )matchesCriteria( Data, criteria = NULL, na.to.false = FALSE, add.details = FALSE, dbg = TRUE )
Data |
data frame |
criteria |
vector of character containing conditions, in which the
column names of |
na.to.false |
if |
add.details |
if |
dbg |
if TRUE (default) for each criterion in |
vector of logical containing TRUE at positions representing rows in
Data fulfilling the conditions and FALSE elsewhere
# Define an example data frame Data <- data.frame(A = c("x", "y", "z", NA), B = c( NA, 2, 3, 4)) # Define one or more criteria criteria <- c("A %in% c('y', 'z')", "B %in% 1:3") # For which rows the criteria are met (vector of logical)? matchesCriteria(Data, criteria, dbg = FALSE) # You may use the function in the context of indexing: Data[matchesCriteria(Data, criteria), ] # Filtering for non-NA values D1 <- Data[matchesCriteria(Data, "! is.na(A) & ! is.na(B)"), ] # the same result is returned by: D2 <- Data[matchesCriteria(Data, c("! is.na(A)", "! is.na(B)")), ] identical(D1, D2)# Define an example data frame Data <- data.frame(A = c("x", "y", "z", NA), B = c( NA, 2, 3, 4)) # Define one or more criteria criteria <- c("A %in% c('y', 'z')", "B %in% 1:3") # For which rows the criteria are met (vector of logical)? matchesCriteria(Data, criteria, dbg = FALSE) # You may use the function in the context of indexing: Data[matchesCriteria(Data, criteria), ] # Filtering for non-NA values D1 <- Data[matchesCriteria(Data, "! is.na(A) & ! is.na(B)"), ] # the same result is returned by: D2 <- Data[matchesCriteria(Data, c("! is.na(A)", "! is.na(B)")), ] identical(D1, D2)
Convert a Matrix to a Data Frame (in "Long" Format)
matrixToDataFrame( x, name_row = NULL, name_column = NULL, name_value = "value", row_first = TRUE )matrixToDataFrame( x, name_row = NULL, name_column = NULL, name_value = "value", row_first = TRUE )
x |
matrix |
name_row |
name to be given to the data frame column containing the
row "coordinates". Default: |
name_column |
name to be given to the data frame column containing the
column "coordinates". Default: |
name_value |
name to be given to the data frame column containing the
matrix values. Default: |
row_first |
if |
data frame with three columns: 1. row "coordinate", 2. column "coordinate", 3. value
m1 <- matrix(1:12, nrow = 3, dimnames = list(NULL, letters[1:4])) m2 <- matrix(1:12, nrow = 3, dimnames = list(index = NULL, letters[1:4])) m3 <- matrix(1:12, nrow = 3, dimnames = list(NULL, letter = letters[1:4])) matrixToDataFrame(x = m1) matrixToDataFrame(x = m1, row_first = FALSE) matrixToDataFrame(x = m2) matrixToDataFrame(x = m3) matrixToDataFrame(x = m3, "myrow", "mycol", "myval")m1 <- matrix(1:12, nrow = 3, dimnames = list(NULL, letters[1:4])) m2 <- matrix(1:12, nrow = 3, dimnames = list(index = NULL, letters[1:4])) m3 <- matrix(1:12, nrow = 3, dimnames = list(NULL, letter = letters[1:4])) matrixToDataFrame(x = m1) matrixToDataFrame(x = m1, row_first = FALSE) matrixToDataFrame(x = m2) matrixToDataFrame(x = m3) matrixToDataFrame(x = m3, "myrow", "mycol", "myval")
Maximum String Length in Vector of Character
maxStringLength(x)maxStringLength(x)
x |
vector of character |
integer representing the length of the longest string in x
maxStringLength(c("a", "ab", "abc", "x", "xy-z"))maxStringLength(c("a", "ab", "abc", "x", "xy-z"))
Merge multiple data frames, given in a list
mergeAll(dataFrames, by, ..., dbg = TRUE)mergeAll(dataFrames, by, ..., dbg = TRUE)
dataFrames |
list of data frames. If the list elements are named, the element names are used as suffixes in the column names, otherwise suffixes ".1", ".2", etc are used |
by |
vector of column names to be merged by, passed on to |
... |
additional arguments passed to |
dbg |
if |
data frame being the result of merging all the data frames given in
dataFrames by consecutively calling merge
peter <- data.frame(fruit = c("apple", "pear", "banana"), kg = 1:3) paul <- data.frame(fruit = c("banana", "apple", "lemon"), kg = c(10, 20, 30)) mary <- data.frame(fruit = c("lemon", "organger", "apple"), kg = c(22, 33, 44)) # By default only categories that are in all data frames are returned mergeAll(list(peter = peter, paul = paul, mary = mary), by = "fruit") # Use the arguments supported by merge to change that behaviour mergeAll(list(peter = peter, paul = paul, mary = mary), by = "fruit", all = TRUE)peter <- data.frame(fruit = c("apple", "pear", "banana"), kg = 1:3) paul <- data.frame(fruit = c("banana", "apple", "lemon"), kg = c(10, 20, 30)) mary <- data.frame(fruit = c("lemon", "organger", "apple"), kg = c(22, 33, 44)) # By default only categories that are in all data frames are returned mergeAll(list(peter = peter, paul = paul, mary = mary), by = "fruit") # Use the arguments supported by merge to change that behaviour mergeAll(list(peter = peter, paul = paul, mary = mary), by = "fruit", all = TRUE)
Merge Lists Overriding Elements of the Same Name
mergeLists(..., warn.on.NULL = TRUE)mergeLists(..., warn.on.NULL = TRUE)
... |
lists |
warn.on.NULL |
if TRUE (default) a warning is given if any of the arguments given to this function is NULL |
list containing the elements given in ...
# merge two lists with different elements mergeLists(list(a = 1), list(b = 2)) # merge two lists with one element of the same name: override element "b" mergeLists(list(a = 1, b = 2), list(b = 3, c = 4))# merge two lists with different elements mergeLists(list(a = 1), list(b = 2)) # merge two lists with one element of the same name: override element "b" mergeLists(list(a = 1, b = 2), list(b = 3, c = 4))
Merge List of Named Arrays
mergeNamedArrays(x, check_dim = TRUE)mergeNamedArrays(x, check_dim = TRUE)
x |
list of arrays of the same dimension |
check_dim |
logical. If |
a1 <- array( 1:12, dim = c(2, 4, 2), dimnames = list(paste0("x", 1:2), paste0("y", 1:4), paste0("z", 1:2)) ) a2 <- array( 11:16, dim = c(1, 3, 2), dimnames = list("x3", paste0("y", 2:4), paste0("z", 1:2)) ) mergeNamedArrays(list(a1, a2))a1 <- array( 1:12, dim = c(2, 4, 2), dimnames = list(paste0("x", 1:2), paste0("y", 1:4), paste0("z", 1:2)) ) a2 <- array( 11:16, dim = c(1, 3, 2), dimnames = list("x3", paste0("y", 2:4), paste0("z", 1:2)) ) mergeNamedArrays(list(a1, a2))
Move columns of a data frame or matrix to the left
moveColumnsToFront(x, columns = NULL)moveColumnsToFront(x, columns = NULL)
x |
data frame |
columns |
vector of column names |
data frame or matrix with columns being the leftmost columns
x <- data.frame(a = 1:5, b = 2:6, c = 3:7) moveColumnsToFront(x, "b") moveColumnsToFront(x, c("b", "a"))x <- data.frame(a = 1:5, b = 2:6, c = 3:7) moveColumnsToFront(x, "b") moveColumnsToFront(x, c("b", "a"))
Move elements to the start of a vector
moveToFront(x, elements)moveToFront(x, elements)
x |
vector |
elements |
elements out of |
vector with elements coming first
moveToFront(1:10, 5) moveToFront(c("a", "b", "c", "x", "y", "d"), c("x", "y"))moveToFront(1:10, 5) moveToFront(c("a", "b", "c", "x", "y", "d"), c("x", "y"))
Calculate moving sum of n values "around" values
movingSum(x, n, na.rm = FALSE)movingSum(x, n, na.rm = FALSE)
x |
vector of values of which moving sum is to be calculated |
n |
number of values "around" the values in |
na.rm |
logical. Should missing values (including NaN) be omitted from the calculations? |
Vector of moving sums with the same number of values as there are in
x. If na.rm is FALSE, the first (n-1)/2 values
and the last (n-1)/2 values are NA since there are not enough values
at the start and at the end of the vector, respectively, to calculate the
sum.
x <- rnorm(30) plot(x, type = "b", main = "Moving mean over 3, 5, 7 points") times <- 2:4 for (i in times) { lines(movingSum(x, n = 2 * i - 1), col = i, type = "b", lwd = 2) } legend("topright", fill = times, legend = sprintf("n = %d", 2 * times - 1))x <- rnorm(30) plot(x, type = "b", main = "Moving mean over 3, 5, 7 points") times <- 2:4 for (i in times) { lines(movingSum(x, n = 2 * i - 1), col = i, type = "b", lwd = 2) } legend("topright", fill = times, legend = sprintf("n = %d", 2 * times - 1))
Message to be shown if fields/columns are missing
msgAvailableFields(x)msgAvailableFields(x)
x |
vector of character |
Lookup by Matching Values in Multiple Columns
multiColumnLookup(data, lookup, value = NULL, drop = TRUE, includeKeys = FALSE)multiColumnLookup(data, lookup, value = NULL, drop = TRUE, includeKeys = FALSE)
data |
data frame for which to lookup values in the |
lookup |
lookup table defining the key values to be matched against
the values in the corresponding columns in |
value |
name of column(s) in |
drop |
logical indicating whether or not to return a vector instead of
a one-column data frame in case that there is only one value column. The
default is |
includeKeys |
logical indicating whether or not to include the key
column(s) in the returned data frame (for more than one |
If value is of length one and drop = TRUE) a vector
with as many elements as there are rows in data is returned.
Otherwise a data frame with as many rows as there are rows in data
and with the columns named in value is returned.
(persons <- rbind( noFactorDataFrame(name = "Peter", city = "Berlin"), noFactorDataFrame(name = "Paul", city = "Paris"), noFactorDataFrame(name = "Mary", city = "Berlin"), noFactorDataFrame(name = "Paul", city = "Berlin"), noFactorDataFrame(name = "Peter", city = "Paris") )) # Who is cool, which city is cool and which combination is coolest? (is_cool <- kwb.utils::safeRowBindAll(list( noFactorDataFrame(name = "Paul", city = "Berlin", value = "astro-cool"), noFactorDataFrame(city = "Berlin", value = "cool"), noFactorDataFrame(name = "Paul", value = "mega-cool"), noFactorDataFrame(city = "Paris", value = "ca va") ))) # Lookup the coolness based on name and city coolness <- multiColumnLookup(persons, is_cool, value = "value") # Add the coolness column cbind(persons, coolness)(persons <- rbind( noFactorDataFrame(name = "Peter", city = "Berlin"), noFactorDataFrame(name = "Paul", city = "Paris"), noFactorDataFrame(name = "Mary", city = "Berlin"), noFactorDataFrame(name = "Paul", city = "Berlin"), noFactorDataFrame(name = "Peter", city = "Paris") )) # Who is cool, which city is cool and which combination is coolest? (is_cool <- kwb.utils::safeRowBindAll(list( noFactorDataFrame(name = "Paul", city = "Berlin", value = "astro-cool"), noFactorDataFrame(city = "Berlin", value = "cool"), noFactorDataFrame(name = "Paul", value = "mega-cool"), noFactorDataFrame(city = "Paris", value = "ca va") ))) # Lookup the coolness based on name and city coolness <- multiColumnLookup(persons, is_cool, value = "value") # Add the coolness column cbind(persons, coolness)
apply multiple substitutions on a vector of character. For each element in replacements gsub is called with the element name being the pattern and the element value being the replacement.
multiSubstitute(strings, replacements, ..., dbg = FALSE)multiSubstitute(strings, replacements, ..., dbg = FALSE)
strings |
vector of character |
replacements |
list of pattern = replacement pairs. |
... |
additional arguments passed to gsub |
dbg |
if |
Call a function and show the elapsed time using system.time)
mySystemTime(FUN, args)mySystemTime(FUN, args)
FUN |
function to be called |
args |
list of arguments passed to |
name the elements of a list of lists by the value of the element
elementName of each sublist
nameByElement(x, elementName = "name")nameByElement(x, elementName = "name")
x |
list of lists |
elementName |
name of element to be looked up in each sublist of
|
L <- list( list(group = "A", value = 1), list(group = "B", value = 2) ) nameByElement(L, "group")L <- list( list(group = "A", value = 1), list(group = "B", value = 2) ) nameByElement(L, "group")
Create Named Vector from two Columns of a Data Frame
namedVectorFromColumns(data, valueColumn, nameColumn)namedVectorFromColumns(data, valueColumn, nameColumn)
data |
a data frame |
valueColumn |
name of column in |
nameColumn |
name of column in |
vector with values in data[[valueColumn]], named by
data[[nameColumn]]
data <- data.frame(a = 1:3, name = LETTERS[1:3]) namedVectorFromColumns(data, valueColumn = "a", nameColumn = "name")data <- data.frame(a = 1:3, name = LETTERS[1:3]) namedVectorFromColumns(data, valueColumn = "a", nameColumn = "name")
Convert a Named Vector to a Data Frame
namedVectorToDataFrame(x)namedVectorToDataFrame(x)
x |
named vector |
data frame with columns name, containing the names of x
and value, containing the values of x
namedVectorToDataFrame(c(a = 1, b = 2, c = 3))namedVectorToDataFrame(c(a = 1, b = 2, c = 3))
replace NA values in a vector with the "last" non-NA values (at the nearest smaller indices in each case) in the vector
naToLastNonNa(x, method = 2)naToLastNonNa(x, method = 2)
x |
vector in which NA are to be replaced with the last non-NA value (at greatest of smaller indices) in the vector |
method |
integer (1 or 2) distinguishing two different methods |
naToLastNonNa(c(1, 2, NA, NA, 3, NA, NA, 4, NA, NA, 5)) ## Result: [1] 1 2 2 2 3 3 3 4 4 4 5 # You will get an error if method = 1 and the first element is NA! # naToLastNonNa(c(NA, 1, NA, 2), method = 1) ## Error in naToLastNonNa(c(NA, 1, NA, 2)) : ## The first element must not be NAnaToLastNonNa(c(1, 2, NA, NA, 3, NA, NA, 4, NA, NA, 5)) ## Result: [1] 1 2 2 2 3 3 3 4 4 4 5 # You will get an error if method = 1 and the first element is NA! # naToLastNonNa(c(NA, 1, NA, 2), method = 1) ## Error in naToLastNonNa(c(NA, 1, NA, 2)) : ## The first element must not be NA
Number of NA values
nNA(x)nNA(x)
x |
vector |
number of NA values in x
nNA(1:3) nNA(c(1, NA, 3))nNA(1:3) nNA(c(1, NA, 3))
Use data.frame with stringsAsFactors = FALSE
noFactorDataFrame(...)noFactorDataFrame(...)
... |
passed to |
# data.frame() by default converts character to factor str(data.frame(id = 1:3, letter = LETTERS[1:3])) # noFactorDataFrame keeps character as character str(noFactorDataFrame(id = 1:3, letter = LETTERS[1:3]))# data.frame() by default converts character to factor str(data.frame(id = 1:3, letter = LETTERS[1:3])) # noFactorDataFrame keeps character as character str(noFactorDataFrame(id = 1:3, letter = LETTERS[1:3]))
Message on Missing Elements
noSuchElements(x, available, type = "element", sorted = TRUE, suffix = "")noSuchElements(x, available, type = "element", sorted = TRUE, suffix = "")
x |
name of element that was not found |
available |
names of elements that are available |
type |
type of element to appear in the message. Default: "element" |
sorted |
logical. Whether or not to print the available elements in
lexical order. Default: |
suffix |
suffix to be appended to |
cat(kwb.utils:::noSuchElements("x", LETTERS[1:3])) cat(kwb.utils:::noSuchElements(c("x", "y"), LETTERS[1:3], suffix = "s"))cat(kwb.utils:::noSuchElements("x", LETTERS[1:3])) cat(kwb.utils:::noSuchElements(c("x", "y"), LETTERS[1:3], suffix = "s"))
Number of Unique Values
nUnique(x)nUnique(x)
x |
R object that function |
Number of unique values in x (integer)
nUnique(1:3) nUnique(c(1, 1, 2))nUnique(1:3) nUnique(c(1, 1, 2))
Object Size and Sizes of Sub Structures in Mb
objectSize(x, max_depth = 2, units = "auto", depth = 0)objectSize(x, max_depth = 2, units = "auto", depth = 0)
x |
object |
max_depth |
number of sub levels of list structures to be shown |
units |
passed to |
depth |
depth of recursive call (for internal use only) |
if x is a list, a list of the same structure is returned with
each list elemenet replaced by its size, otherwise the object size of
x. Each list or sub list with more than one element is assigned an
attribute "total" to containing the total size of the list.
Convert R Object to Text Representation
objectToText(x)objectToText(x)
x |
R object |
vector of character representing the R code that reproduces the
object x
objectToText(1:10) objectToText((1:10)[-5]) cat(objectToText(head(iris)))objectToText(1:10) objectToText((1:10)[-5]) cat(objectToText(head(iris)))
Order a Data Frame by One or more Columns
orderBy(df, by = NULL, ...)orderBy(df, by = NULL, ...)
df |
data frame |
by |
vector of column names specifying the columns by which to order |
... |
further arguments passed to |
df being sorted and with newly renumbered rows
orderBy(iris, by = "Sepal.Length") orderBy(iris, by = "Species", decreasing = TRUE) orderBy( iris, by = c("Species", "Petal.Width", "Petal.Length"), decreasing = TRUE )orderBy(iris, by = "Sepal.Length") orderBy(iris, by = "Species", decreasing = TRUE) orderBy( iris, by = c("Species", "Petal.Width", "Petal.Length"), decreasing = TRUE )
Order Data Frame Decreasingly by one Column
orderDecreasinglyBy(df, column)orderDecreasinglyBy(df, column)
df |
data frame |
column |
name of column by which to order decreasingly. |
(df <- data.frame(a = 1:3, b = 11:13)) orderDecreasinglyBy(df, "a")(df <- data.frame(a = 1:3, b = 11:13)) orderDecreasinglyBy(df, "a")
Reorder strings so that strings that start with the same characters appear next to each other
pairwise(x, starts = defaultStarts(x, split), split = "_")pairwise(x, starts = defaultStarts(x, split), split = "_")
x |
vector of character |
starts |
vector of character defining the start strings that are looked
for in |
split |
split character used to create default |
x <- c("a.1", "b_hi", "c", "a.2", "d", "b_bye") # You have the most control when setting the starts argument pairwise(x, starts = c("a.", "b_")) # Use default starts resulting from splitting at a split character pairwise(x, split = "_") # This is actually the default pairwise(x) # Note that the split parameter is interpreted as a pattern where the # dot has a special meaning unless it is escaped or enclosed in [] pairwise(x, split = "[.]") # Same result as in the first example pairwise(x, split = "[._]")x <- c("a.1", "b_hi", "c", "a.2", "d", "b_bye") # You have the most control when setting the starts argument pairwise(x, starts = c("a.", "b_")) # Use default starts resulting from splitting at a split character pairwise(x, split = "_") # This is actually the default pairwise(x) # Note that the split parameter is interpreted as a pattern where the # dot has a special meaning unless it is escaped or enclosed in [] pairwise(x, split = "[.]") # Same result as in the first example pairwise(x, split = "[._]")
two vectors a and b of same length are merged in such a way that at index i the result vector contains (1) a[i] if a[i] is not NA and b[i] is NA or b[i] == a[i], (2) b[i] if b[i] is not NA and a[i] is NA or a[i] == b[i], (3) "" if a[i] is not NA and b[i] is not NA and a[i] != b[i] or if both a[i] and b[i] are NA
parallelNonNA(a, b)parallelNonNA(a, b)
a |
vector 1 |
b |
vector 2 |
character vector of same length as a and b
parallelNonNA(c(1, NA, 3), c(NA, 2, NA)) # "1" "2" "3" parallelNonNA(c(1, NA, NA), c(NA, 2, NA)) # "1" "2" "" ## A warning is given if (non-NA) values at the same index differ y <- parallelNonNA(c(1, 2, 3), c(1, 2, 4)) y # "1" "2" "" ## attribute "invalid" contains the index and values of the differing values attr(y, "invalid")parallelNonNA(c(1, NA, 3), c(NA, 2, NA)) # "1" "2" "3" parallelNonNA(c(1, NA, NA), c(NA, 2, NA)) # "1" "2" "" ## A warning is given if (non-NA) values at the same index differ y <- parallelNonNA(c(1, 2, 3), c(1, 2, 4)) y # "1" "2" "" ## attribute "invalid" contains the index and values of the differing values attr(y, "invalid")
Paste Columns of Data Frame With Separator
pasteColumns(x, columns = names(x), sep = " ", ...)pasteColumns(x, columns = names(x), sep = " ", ...)
x |
data frame |
columns |
names of columns to be pasted. Default: all columns |
sep |
separator character. Default: space (" ") |
... |
args passed to |
vector of character with each element representing the values of the selected columns of one row, being pasted with the separator character
x <- data.frame(A = 1:3, B = 2:4) pasteColumns(x, sep = ";")x <- data.frame(A = 1:3, B = 2:4) pasteColumns(x, sep = ";")
Paste Columns of Data Frame Without Separator
pasteColumns0(x, columns = names(x), ...)pasteColumns0(x, columns = names(x), ...)
x |
data frame |
columns |
names of columns to be pasted. Default: all columns |
... |
args passed to |
vector of character with each element representing the values of the selected columns of one row, being pasted without a separator
x <- data.frame(A = 1:3, B = 2:4) pasteColumns0(x)x <- data.frame(A = 1:3, B = 2:4) pasteColumns0(x)
x / basis, in percent
percentage(x, basis)percentage(x, basis)
x |
numeric |
basis |
numeric |
100 * x / basis
Percentage of Maximum
percentageOfMaximum(x, na.rm = TRUE)percentageOfMaximum(x, na.rm = TRUE)
x |
vector of numeric values |
na.rm |
passed to |
100 * x / max(x)
Percentage of the Sum of Values
percentageOfSum(x, na.rm = TRUE)percentageOfSum(x, na.rm = TRUE)
x |
vector of numeric values |
na.rm |
passed to |
100 * x / sum(x)
p <- percentageOfSum(1:10) stopifnot(sum(p) == 100)p <- percentageOfSum(1:10) stopifnot(sum(p) == 100)
Indices of POSIX columns in a Data Frame
posixColumnAtPosition(x)posixColumnAtPosition(x)
x |
data frame containing a date/time column |
Opens a PDF device in A4 paper format. After calling this function all plots
go into the specified PDF file in pdfFile. Important: The PDF file
needs to be closed explicitely with grDevices::dev.off() after all desired
plots have been made.
preparePdf( pdfFile = tempfile(fileext = ".pdf"), landscape = TRUE, borderWidth.cm = 2, borderHeight.cm = 2, width.cm = NULL, height.cm = NULL, makeCurrent = TRUE, paper = NULL, ... )preparePdf( pdfFile = tempfile(fileext = ".pdf"), landscape = TRUE, borderWidth.cm = 2, borderHeight.cm = 2, width.cm = NULL, height.cm = NULL, makeCurrent = TRUE, paper = NULL, ... )
pdfFile |
Full path to PDF file to be created |
landscape |
If |
borderWidth.cm |
(Total) border width in "width" direction in cm |
borderHeight.cm |
(Total) border width in "height" direction in cm |
width.cm |
page width in cm. Default according to DIN A4 |
height.cm |
page height in cm. Default according to DIN A4 |
makeCurrent |
if |
paper |
passed to |
... |
further arguments passed to |
full path to pdf file
## Not run: # Open PDF file by giving a path to preparePdf(). The path is returned. pdf_file <- preparePdf(file.path(tempdir(), "example_preparePdf.pdf")) # Plot something plot(x <- seq(-pi,pi,pi/100), sin(x), type = "l") # Open PDF file in viewer finishAndShowPdf(pdf_file) ## End(Not run)## Not run: # Open PDF file by giving a path to preparePdf(). The path is returned. pdf_file <- preparePdf(file.path(tempdir(), "example_preparePdf.pdf")) # Plot something plot(x <- seq(-pi,pi,pi/100), sin(x), type = "l") # Open PDF file in viewer finishAndShowPdf(pdf_file) ## End(Not run)
Prepare PDF File if Condition is Met
preparePdfIf(to.pdf, PDF = "", ...)preparePdfIf(to.pdf, PDF = "", ...)
to.pdf |
condition determining whether |
PDF |
full path to PDF file. If this is an empty string (default) a temporary file is created and its path returned |
... |
arguments passed to |
full path to pdf file created if condition is met or "" else
Print Method for Object of Class "repro_sample"
## S3 method for class 'repro_sample' print(x, ...)## S3 method for class 'repro_sample' print(x, ...)
x |
object to be printed |
... |
further arguments, not used. |
Different Sets of Printable ASCII Characters
printable_chars(level = 1)printable_chars(level = 1)
level |
one of 1, 2, or 3. Level 1 characters comprise the ten digits 0 to 9 and 26 uppercase letters. Level 2 characters comprise the characters of level 1 as well as 26 lowercase letters. Level 3 characters comprise altogether 88 printable characters. |
vector of character
printable_chars(1) printable_chars(2) printable_chars(3)printable_chars(1) printable_chars(2) printable_chars(3)
Call Print If Condition Is Met
printIf(condition, x, caption = deparse(substitute(x)))printIf(condition, x, caption = deparse(substitute(x)))
condition |
if TRUE, print is called, else not |
x |
object to be printed |
caption |
optional. Caption line to be printed with cat before printing x |
Calculate the quotient of two numbers
quotient(dividend, divisor, substitute.value = Inf, warn = TRUE)quotient(dividend, divisor, substitute.value = Inf, warn = TRUE)
dividend |
number to be devided |
divisor |
number by which dividend is to be devided |
substitute.value |
value to be returned if divisor is 0 |
warn |
if TRUE, a warning is given if the divisor is zero |
quotient of dividend and divisor: dividend/divisor
Create a matrix of given dimension and fill it with random integer values
randomMatrix(dim = c(sample(10, 1), sample(10, 1)), values = seq_len(100))randomMatrix(dim = c(sample(10, 1), sample(10, 1)), values = seq_len(100))
dim |
integer vector of length two containing the number of rows and columns, respectively, that the output matrix shall contain |
values |
set of values to be used within the matrix |
# By default, the matrix has a random number of rows between 1 and 10 and # a random number of columns between 1 and 10 and random values of 1:100 randomMatrix() # You may specify the dimensions (here: 5 rows, 3 columns)... randomMatrix(dim = c(5, 3)) # ... and the set of values to be used within the matrix randomMatrix(dim = c(5, 3), values = c(0, 0.5, 1, NA))# By default, the matrix has a random number of rows between 1 and 10 and # a random number of columns between 1 and 10 and random values of 1:100 randomMatrix() # You may specify the dimensions (here: 5 rows, 3 columns)... randomMatrix(dim = c(5, 3)) # ... and the set of values to be used within the matrix randomMatrix(dim = c(5, 3), values = c(0, 0.5, 1, NA))
Vector of random Integer Values of given Sum
randomValuesWithSum(n, sumOfValues, names = seq_len(n))randomValuesWithSum(n, sumOfValues, names = seq_len(n))
n |
number of values |
sumOfValues |
sum of values in the result vector |
names |
names of elements in the result vector. Default:
|
named vector of integer values with sum(values) == sumOfValues
Create Sequence from Range
rangeToSequence(x)rangeToSequence(x)
x |
numeric vector with exactly two elements |
integer sequence between x[1] and x[2]
rangeToSequence(c(1, 10))rangeToSequence(c(1, 10))
rbind all data frames given in a list
rbindAll(x, nameColumn = "", remove.row.names = TRUE, namesAsFactor = TRUE)rbindAll(x, nameColumn = "", remove.row.names = TRUE, namesAsFactor = TRUE)
x |
list of data frames to be passed to |
nameColumn |
optional. If given, an additional column of that name is added to the resulting data frame containing the name (or number if args is an unnamed list) of the element in x that the corresponding rows belong to |
remove.row.names |
if TRUE (default) row names are reset in the output data frame |
namesAsFactor |
if TRUE (default) and nameColumn is given the values in column nameColumn are converted to a factor |
L <- list( A = data.frame(x = 1:2, y = 2:3), B = data.frame(x = 1:3, y = 2:4) ) L.unnamed <- L names(L.unnamed) <- NULL y1 <- rbindAll(L) y2 <- rbindAll(L, nameColumn = "group") y3 <- rbindAll(L.unnamed, nameColumn = "group", namesAsFactor = FALSE) y4 <- rbindAll(L.unnamed, nameColumn = "group") expected1 <- data.frame( x = c(L$A$x, L$B$x), y = c(L$A$y, L$B$y) ) expected2 <- cbind( expected1, group = as.factor(c(rep("A", nrow(L$A)), rep("B", nrow(L$B)))), stringsAsFactors = FALSE ) expected3 <- cbind( expected1, group = c(rep(1L, nrow(L$A)), rep(2L, nrow(L$B))) ) expected4 <- expected3 expected4$group <- as.factor(expected4$group) identical(y1, expected1) && identical(y2, expected2) && identical(y3, expected3) && identical(y4, expected4)L <- list( A = data.frame(x = 1:2, y = 2:3), B = data.frame(x = 1:3, y = 2:4) ) L.unnamed <- L names(L.unnamed) <- NULL y1 <- rbindAll(L) y2 <- rbindAll(L, nameColumn = "group") y3 <- rbindAll(L.unnamed, nameColumn = "group", namesAsFactor = FALSE) y4 <- rbindAll(L.unnamed, nameColumn = "group") expected1 <- data.frame( x = c(L$A$x, L$B$x), y = c(L$A$y, L$B$y) ) expected2 <- cbind( expected1, group = as.factor(c(rep("A", nrow(L$A)), rep("B", nrow(L$B)))), stringsAsFactors = FALSE ) expected3 <- cbind( expected1, group = c(rep(1L, nrow(L$A)), rep(2L, nrow(L$B))) ) expected4 <- expected3 expected4$group <- as.factor(expected4$group) identical(y1, expected1) && identical(y2, expected2) && identical(y3, expected3) && identical(y4, expected4)
Read argument lists from CSV (or MS Excel) file
readArglists( file = NULL, configTable = readArglistsTable.csv(safePath(file), dbg = dbg), dbg = FALSE )readArglists( file = NULL, configTable = readArglistsTable.csv(safePath(file), dbg = dbg), dbg = FALSE )
file |
full path to comma separated file containing the argument specification |
configTable |
Instead of the file you may provide a data frame containing the configuration |
dbg |
if |
Read CSV File Giving Column Descriptions
readCsvInputFile( csv, sep, dec, headerRow = 1, headerPattern = "", columnDescription = NULL, maxRowToLookForHeader = 10, stopOnMissingColumns = TRUE, fileEncoding = "UTF-8", encoding = "unknown", ... )readCsvInputFile( csv, sep, dec, headerRow = 1, headerPattern = "", columnDescription = NULL, maxRowToLookForHeader = 10, stopOnMissingColumns = TRUE, fileEncoding = "UTF-8", encoding = "unknown", ... )
csv |
full path to CSV file |
sep |
column separator |
dec |
decimal character |
headerRow |
number row in which the header (containing column captions) is found |
headerPattern |
pattern matching the header row. If headerPattern is given headerRow is not considered |
columnDescription |
list of column descriptors. The list elements are named with the name of the list elements being the names that shall be used in the returned data frame. Each list element is a list with elements match (pattern to be looked for in the header fields), ... |
maxRowToLookForHeader |
maximum number of rows to be considered when looking for the header row |
stopOnMissingColumns |
if TRUE (default) the program stops if not all columns defined in columnDescription are found |
fileEncoding |
encoding of the input file |
encoding |
passed to readLines, "Latin-1" or "UTF-8" |
... |
further arguments passed to read.table |
Read files from a folder, specified by a file name pattern, into a list of dictionaries
readDictionaries(folder, pattern = "^dictionary_(.*)[.]txt$")readDictionaries(folder, pattern = "^dictionary_(.*)[.]txt$")
folder |
path to the folder containing the files to be read |
pattern |
regular expression to match the names of the files to be read. The pattern is expected to contain a pair of parentheses around the part of the file that shall be used as element name in the returned list |
Reads a dictionary (a list of "key = value"-pairs) from a text file.
readDictionary(file, sorted = TRUE, fileEncoding = "", ...)readDictionary(file, sorted = TRUE, fileEncoding = "", ...)
file |
full path to dictionary file or connection as e.g. opened with
|
sorted |
if TRUE (default) the entries in the dictionary will be sorted by their keys |
fileEncoding |
passed to |
... |
further arguments passed to |
file <- system.file("extdata", "dictionary.txt", package = "kwb.utils") dictionary <- readDictionary(file) resolve("file.out", dictionary, extension = "csv") resolve("file.out", dictionary, extension = "pdf")file <- system.file("extdata", "dictionary.txt", package = "kwb.utils") dictionary <- readDictionary(file) resolve("file.out", dictionary, extension = "csv") resolve("file.out", dictionary, extension = "pdf")
Read Lines by Giving the File Encoding
readLinesWithEncoding(file, ..., fileEncoding = "", encoding = "unknown")readLinesWithEncoding(file, ..., fileEncoding = "", encoding = "unknown")
file |
a connection object or character string |
... |
arguments passed to |
fileEncoding |
The name of the encoding to be assumed. Passed as
|
encoding |
passed to |
Read File from Package's extdata Folder
readPackageFile(file, package, stringsAsFactors = FALSE, ...)readPackageFile(file, package, stringsAsFactors = FALSE, ...)
file |
name of file (without path) |
package |
name of the package from which to read the file |
stringsAsFactors |
passed to |
... |
further arguments passed to |
result of reading file with utils::read.csv
returns the names of all sublists of x in the "$"-notation, e.g. list$sublist$subsublist$subsubsublist
recursiveNames(x, basename = "")recursiveNames(x, basename = "")
x |
R list. |
basename |
name to be used as prefix for all names found. Default: "" |
"Recycle" Vector to given Length
recycle(x, n)recycle(x, n)
x |
vector to be "recycled" |
n |
target length |
relative cumulated sum of a vector of values
relativeCumulatedSum(values)relativeCumulatedSum(values)
values |
vector of numeric values |
Remove all or selected Attributes of an Object
removeAttributes(x, names = NULL)removeAttributes(x, names = NULL)
x |
object |
names |
names of attributes to be removed. If |
x, but with its attributes removed
Remove Columns from a Data Frame
removeColumns( dframe, columns = NULL, columnsToRemove = NULL, pattern = NULL, drop = FALSE, dbg = FALSE )removeColumns( dframe, columns = NULL, columnsToRemove = NULL, pattern = NULL, drop = FALSE, dbg = FALSE )
dframe |
data frame, |
columns |
vector of column names giving the columns to remove |
columnsToRemove |
deprecated. Use argument |
pattern |
regular expression matching the names of the columns to be
removed. Will only be evaluated if no explicit column names are given in
|
drop |
if FALSE, a data frame is returned in any case, otherwise the result may be a vector if only one column remains |
dbg |
if |
dframe with columns given in columns being removed. User attributes of dframe are restored.
Remove Duplicated Values from a Vector
removeDuplicates(x, dbg = TRUE)removeDuplicates(x, dbg = TRUE)
x |
vector from which to remove duplicates |
dbg |
if |
x with duplicated values being removed
removeDuplicates(c(1, 1, 2, 3, 4, 4))removeDuplicates(c(1, 1, 2, 3, 4, 4))
Remove Elements from a List
removeElements(x, elements)removeElements(x, elements)
x |
a list |
elements |
names of elements to remove |
x with elements with names given in elements being
removed. User attributes of x are restored.
Remove Empty Elements from Vector
removeEmpty(x)removeEmpty(x)
x |
vector |
x with elements for which isNaOrEmpty is
TRUE removed
removeEmpty(c(1, NA, 3)) removeEmpty(c("a", "", "b", NA, "c", " ", "d"))removeEmpty(c(1, NA, 3)) removeEmpty(c("a", "", "b", NA, "c", " ", "d"))
Remove Empty Elements from Vector of Character
removeEmpty2(x, dbg = FALSE)removeEmpty2(x, dbg = FALSE)
x |
vector of character |
dbg |
if |
removeEmpty2(c("a", "", "c")) removeEmpty2(c("a", "", "c", "", "e"), dbg = TRUE)removeEmpty2(c("a", "", "c")) removeEmpty2(c("a", "", "c", "", "e"), dbg = TRUE)
Remove empty Columns from a Data Frame
removeEmptyColumns( x, drop = FALSE, FUN = function(x) all(is.na(x)), dbg = TRUE )removeEmptyColumns( x, drop = FALSE, FUN = function(x) all(is.na(x)), dbg = TRUE )
x |
data frame |
drop |
if |
FUN |
function called on each column to determine if all values in the
column are empty. Default: |
dbg |
if |
data frame x with empty columns (columns with NA in all rows)
being removed
Remove File Name Extension
removeExtension(x)removeExtension(x)
x |
vector of character |
removeExtension("example.R") removeExtension("any/path/example.txt")removeExtension("example.R") removeExtension("any/path/example.txt")
Remove Leading Slashes of Strings
removeLeadingSlashes(x)removeLeadingSlashes(x)
x |
vector of character |
modified version of x with all leading slashes in all elements
of x removed
removeLeadingSlashes(c("a", "/b", "//c"))removeLeadingSlashes(c("a", "/b", "//c"))
Remove all Spaces in String(s)
removeSpaces(x)removeSpaces(x)
x |
(vector of) character |
x with all spaces removed
Rename and Select Columns of a Data Frame
renameAndSelect(data, renames, columns = unlist(renames))renameAndSelect(data, renames, columns = unlist(renames))
data |
data frame |
renames |
list defining renames in the form of "oldName" = "newName" pairs |
columns |
(new) names of columns to be selected |
Rename columns in a data frame giving tupels of original name and substitute name as named elements in list "renames"
renameColumns(x, renamings = NULL)renameColumns(x, renamings = NULL)
x |
data.frame |
renamings |
list with named elements each of which defines a column rename in the form <old-name> = <new-name> |
dframe with columns renamed as specified in renames
Repeated Substring
repeated(x, n)repeated(x, n)
x |
substring to be repeated and pasted together to a new string |
n |
number of times to repeat the substring |
vector of character of length one
repeated("no ", 2) repeated("yes ", 3) repeated("yes no ", 3)repeated("no ", 2) repeated("yes ", 3) repeated("yes no ", 3)
Replace the file name extension in a file name or file path
replaceFileExtension(file, extension)replaceFileExtension(file, extension)
file |
file name or full path to a file |
extension |
new file name extension (including the dot, e.g. ".txt") |
replaceFileExtension(file = "run.bat", ".txt")replaceFileExtension(file = "run.bat", ".txt")
This function calls sample and stores the values that are
required to reproduce the exact same sampling in the attribute
random_seed of the returned vector. When this attribute is passed
to another call of this function, the values returned will be the same as
in the first call.
reproducibleSample(..., FUN = sample, random_seed = NULL)reproducibleSample(..., FUN = sample, random_seed = NULL)
... |
arguments passed to |
FUN |
the sample function to be called. Default: |
random_seed |
vector of integer as stored in |
This function returns what sample returns with an
attribute random_seed attached.
# Take a sample x <- reproducibleSample(1:100, 10) x # The full seed vector is returned in the attribute "random_seed" random_seed <- attr(x, "random_seed") # Take a new sample, this time passing the seed vector y <- reproducibleSample(1:100, 10, random_seed = random_seed) y # The values are identical to the values of the first sampling identical(x, y)# Take a sample x <- reproducibleSample(1:100, 10) x # The full seed vector is returned in the attribute "random_seed" random_seed <- attr(x, "random_seed") # Take a new sample, this time passing the seed vector y <- reproducibleSample(1:100, 10, random_seed = random_seed) y # The values are identical to the values of the first sampling identical(x, y)
Reset the row names of a data frame x to 1:nrow(x) by setting the
row.names attribute to NULL.
resetRowNames(x)resetRowNames(x)
x |
data frame or matrix |
persons <- data.frame(id = c(1, 2, 3), name = c("Peter", "Paul", "Mary")) persons.ordered <- persons[order(persons$name), ] # Original row names persons.ordered # Reset row names resetRowNames(persons.ordered)persons <- data.frame(id = c(1, 2, 3), name = c("Peter", "Paul", "Mary")) persons.ordered <- persons[order(persons$name), ] # Original row names persons.ordered # Reset row names resetRowNames(persons.ordered)
Resolve String(s) Using a Dictionary
resolve(x, ...)resolve(x, ...)
x |
vector of character to be resolved or a list of which all elements
will be resolved using itself as a "dictionary". A dictionary is a list of
|
... |
Unnamed arguments are treated as (further) dictionaries. These
are merged first to one dictionary before merging further (named) |
file <- system.file("extdata", "dictionary.txt", package = "kwb.utils") dictionary <- readDictionary(file) # Resolve the dictionary resolve(dictionary) # Resolve the dictionary by setting an undefined placeholder resolve(dictionary, extension = "pdf") # Resolve a string resolve("dir.project", dictionary) # Set a placeholder "on-the-fly" resolve("file.out", dictionary, extension = "pdf") # Override a placeholder "on-the-fly" resolve("dir.project", dictionary, project = "new_project") # Resolve a vector of strings resolve(c("dir.root", "dir.project"), dictionary, project = "vector")file <- system.file("extdata", "dictionary.txt", package = "kwb.utils") dictionary <- readDictionary(file) # Resolve the dictionary resolve(dictionary) # Resolve the dictionary by setting an undefined placeholder resolve(dictionary, extension = "pdf") # Resolve a string resolve("dir.project", dictionary) # Set a placeholder "on-the-fly" resolve("file.out", dictionary, extension = "pdf") # Override a placeholder "on-the-fly" resolve("dir.project", dictionary, project = "new_project") # Resolve a vector of strings resolve(c("dir.root", "dir.project"), dictionary, project = "vector")
Resolve all Placeholders in a Dictionary
resolveAll(dictionary, ...)resolveAll(dictionary, ...)
dictionary |
list with named elements where the element name represents the key and the element value represents the value assigned to the key. |
... |
additional assignments of the form <key> = <value> that are
temporarily added to the |
# Define a dictionary in the form of a list dictionary <- list( basedir = "C:/myNicefolder", projectdir = "<basedir>/projects/<project_name>", inputdir = "<projectdir>/input", outputdir = "<projectdir>/output" ) # Resolve all entries in the dictionary, with different values for the # placeholder "<project_name> which is undefined in the original dictionary dictionary.1 <- resolveAll(dictionary, project_name = "project_1") dictionary.2 <- resolveAll(dictionary, project_name = "project_2") # Define entries of the dictionary to resolve keys <- c("inputdir", "outputdir") # Resolve the entries using the two different dictionaries resolve(keys, dictionary.1) resolve(keys, dictionary.2)# Define a dictionary in the form of a list dictionary <- list( basedir = "C:/myNicefolder", projectdir = "<basedir>/projects/<project_name>", inputdir = "<projectdir>/input", outputdir = "<projectdir>/output" ) # Resolve all entries in the dictionary, with different values for the # placeholder "<project_name> which is undefined in the original dictionary dictionary.1 <- resolveAll(dictionary, project_name = "project_1") dictionary.2 <- resolveAll(dictionary, project_name = "project_2") # Define entries of the dictionary to resolve keys <- c("inputdir", "outputdir") # Resolve the entries using the two different dictionaries resolve(keys, dictionary.1) resolve(keys, dictionary.2)
Switch list elements with their names
revertListAssignments(x)revertListAssignments(x)
x |
list of named elements |
list with the names of x as elements and the elements of x as names
abbreviation <- list(de = "Germany", en = "England") revertListAssignments(abbreviation) ## reverting twice results in the original list identical( abbreviation, revertListAssignments(revertListAssignments(abbreviation)) )abbreviation <- list(de = "Germany", en = "England") revertListAssignments(abbreviation) ## reverting twice results in the original list identical( abbreviation, revertListAssignments(revertListAssignments(abbreviation)) )
Right Part of a String
right(x, n)right(x, n)
x |
vector of character |
n |
number of characters to be kept from the end of each character
string within |
vector of character
right("Good Morning", 7)right("Good Morning", 7)
Round Columns to given Number of Digits
roundColumns( dframe, columns = NULL, digits = NULL, pattern = NULL, columnNames = NULL )roundColumns( dframe, columns = NULL, digits = NULL, pattern = NULL, columnNames = NULL )
dframe |
data frame containing numeric columns to be rounded |
columns |
names of (numeric) columns in |
digits |
number of digits to be rounded to (vector of length 1 expected)
or list of assignments in the form: |
pattern |
regular expression matching the names of the columns to be
rounded. Will only be evaluated if no explicit column names are given in
|
columnNames |
deprecated. Use argument |
dframe with columns given in columnNames being rounded
to digits digits.
Calculate the percentage (value divided by sum of values in the row/column) for each row/column
rowOrColumnwisePercentage(x, rowwise, default = 0, digits = 1)rowOrColumnwisePercentage(x, rowwise, default = 0, digits = 1)
x |
two dimensional numeric data structure |
rowwise |
if |
default |
default value to be used if the calculated percentage is
|
digits |
number of digits (default: 1) to which the resulting
percentages are to be rounded. Set to |
rowwisePercentage, columnwisePercentage
Calculate the percentage (value divided by sum of values in the row) for each row
rowwisePercentage(x, default = 0, digits = 1)rowwisePercentage(x, default = 0, digits = 1)
x |
two dimensional numeric data structure |
default |
default value to be used if the calculated percentage is
|
digits |
number of digits (default: 1) to which the resulting
percentages are to be rounded. Set to |
# Create a random matrix of integer values M1 <- matrix(sample(100, 12), nrow = 4, dimnames = list(LETTERS[1:4], 1:3)) # Introduce some NA values <- as.numeric(M1) values[sample(length(values), 3)] <- NA M2 <- matrix(values, nrow = nrow(M1), dimnames = dimnames(M1)) M1 rowwisePercentage(M1) M2 rowwisePercentage(M2) rowwisePercentage(M2, default = 0)# Create a random matrix of integer values M1 <- matrix(sample(100, 12), nrow = 4, dimnames = list(LETTERS[1:4], 1:3)) # Introduce some NA values <- as.numeric(M1) values[sample(length(values), 3)] <- NA M2 <- matrix(values, nrow = nrow(M1), dimnames = dimnames(M1)) M1 rowwisePercentage(M1) M2 rowwisePercentage(M2) rowwisePercentage(M2, default = 0)
R compatible file path with backslashes replaced with forward slashes
rStylePath(path)rStylePath(path)
path |
character string representing a file path |
path in which backslashes are replaced with forward slashes
Run a Batch File in a given Directory
runBatchfileInDirectory(batchfile, directory = dirname(batchfile), ...)runBatchfileInDirectory(batchfile, directory = dirname(batchfile), ...)
batchfile |
full path to Windows batch file |
directory |
directory from which batchfile is to be invoked. Default: directory of batch file |
... |
arguments passed to shell.exec |
Change Working Directory and Run Function
runInDirectory(target.dir = tempdir(), FUN, ..., .dbg = FALSE)runInDirectory(target.dir = tempdir(), FUN, ..., .dbg = FALSE)
target.dir |
target directory. Default: |
FUN |
function to be invoked |
... |
arguments to be passed to function FUN |
.dbg |
if TRUE, debug messages on changing the directory are shown.
Default: |
If x1 is NULL x2 is returned otherwise cbind(x1, x2)
safeColumnBind(x1, x2)safeColumnBind(x1, x2)
x1 |
first object to be passed to |
x2 |
second object to be passed to |
result of cbind(x1, x2) or x2 if x1
is NULL.
x1 <- NULL for (i in 1:3) { x2 <- data.frame(a = 1:3, b = rnorm(3)) x1 <- safeColumnBind(x1, x2) # using cbind would result in an error: # x1 <- cbind(x1, x2) } x1x1 <- NULL for (i in 1:3) { x2 <- data.frame(a = 1:3, b = rnorm(3)) x1 <- safeColumnBind(x1, x2) # using cbind would result in an error: # x1 <- cbind(x1, x2) } x1
check existence of columns before merging
safeMerge(x, y, by = intersect(names(x), names(y)), by.x = by, by.y = by, ...)safeMerge(x, y, by = intersect(names(x), names(y)), by.x = by, by.y = by, ...)
x |
just as in |
y |
just as in |
by |
just as in |
by.x |
just as in |
by.y |
just as in |
... |
additional arguments passed to |
Check if file or folder path exists and return the path or stop if the path does not exist
safePath(...)safePath(...)
... |
character vectors passed to |
path as given in path
rbind two data frames even if column names differ
safeRowBind(dataFrame1, dataFrame2)safeRowBind(dataFrame1, dataFrame2)
dataFrame1 |
first data frame |
dataFrame2 |
second data frame |
kwb.utils::safeRowBind( data.frame(A = 1:2, B = 2:3), data.frame(B = 3:4, C = 4:5) )kwb.utils::safeRowBind( data.frame(A = 1:2, B = 2:3), data.frame(B = 3:4, C = 4:5) )
rbind all data frames in a list using safeRowBind
safeRowBindAll(x)safeRowBindAll(x)
x |
list of data frames |
data frame resulting from "rbind"-ing all data frames in x
row-bind data frames in a list of lists
safeRowBindOfListElements(x, elementName)safeRowBindOfListElements(x, elementName)
x |
list of lists each of which contains a data frame in element elementName |
elementName |
name of list element in each sublist of x which contains a data frame |
data frame resulting from "row-binding" data frames.
x <- list( list( number = 1, data = data.frame(x = 1:2, y = 2:3) ), list( number = 2, data = data.frame(x = 11:12, y = 12:13) ) ) safeRowBindOfListElements(x, "data") # also working if the column names of the data frames in the "data" elements # differ. x[[1]]$data$z = 13:14 safeRowBindOfListElements(x, "data")x <- list( list( number = 1, data = data.frame(x = 1:2, y = 2:3) ), list( number = 2, data = data.frame(x = 11:12, y = 12:13) ) ) safeRowBindOfListElements(x, "data") # also working if the column names of the data frames in the "data" elements # differ. x[[1]]$data$z = 13:14 safeRowBindOfListElements(x, "data")
Select columns from a data frame. Stop with message if columns do not exist
selectColumns( x, columns = NULL, pattern = NULL, drop = (length(columns) == 1), do.stop = TRUE )selectColumns( x, columns = NULL, pattern = NULL, drop = (length(columns) == 1), do.stop = TRUE )
x |
data frame |
columns |
vector of column names. If |
pattern |
regular expression matching the names of the columns to be
selected. Will only be evaluated if no explicit column names are given in
|
drop |
if |
do.stop |
this flag controls whether the function stops ( |
data frame containing the columns of x that are specified in
columns or x itself if columns is NULL or a
vector containing the values of column value if columns is of
length 1 and drop = TRUE (which is the default in this case).
select (and rename, if required) elements from list. Stop with message if elements do not exist
selectElements(x, elements = NULL, do.stop = TRUE, do.warn = TRUE)selectElements(x, elements = NULL, do.stop = TRUE, do.warn = TRUE)
x |
list |
elements |
vector of element names. The names of named elements will be the names in the output list |
do.stop |
this flag controls whether the function stops ( |
do.warn |
if |
list containing the elements of x that are specified in
elements or x[[elements]] if length of elements is 1
or list() if elements is empty. If the elements in vector
elements are named, these names are used in the output list.
L <- list(a = 1, b = 2, c = 3, d = 4) # Select elements selectElements(L, c("a", "c")) # Select and rename at the same time selectElements(L, elements = c(a.new = "a", c.new = "c", "b"))L <- list(a = 1, b = 2, c = 3, d = 4) # Select elements selectElements(L, c("a", "c")) # Select and rename at the same time selectElements(L, elements = c(a.new = "a", c.new = "c", "b"))
Set the (new or existing) column(s) of a data frame.
setColumns(.x, ..., dbg = TRUE)setColumns(.x, ..., dbg = TRUE)
.x |
data frame |
... |
column assignment(s) in the form of |
dbg |
if |
data frame with columns modified or appended as specified with the
assignments
# Create a data frame x <- data.frame(a = 1:5) # Option 1: use the "$" operator x1 <- x x1$b <- 2:6 x1$c <- 3:7 # Option 2: use setColumns x2 <- setColumns(x, b = 2:6, c = 3:7) # The result is the same identical(x1, x2) # but the creation of columns has been reported on the console (dbg = TRUE by # default) ## Provide column 'b' to data frame 'x'... ok. ## Provide column 'c' to data frame 'x'... ok.# Create a data frame x <- data.frame(a = 1:5) # Option 1: use the "$" operator x1 <- x x1$b <- 2:6 x1$c <- 3:7 # Option 2: use setColumns x2 <- setColumns(x, b = 2:6, c = 3:7) # The result is the same identical(x1, x2) # but the creation of columns has been reported on the console (dbg = TRUE by # default) ## Provide column 'b' to data frame 'x'... ok. ## Provide column 'c' to data frame 'x'... ok.
You may use this function at the last line of your script to indicate that
this script has already been loaded. This information is stored in the R
option "kwb.utils.loaded" from which you may read the information back with
isLoaded.
setLoaded(scriptName, isLoaded = TRUE)setLoaded(scriptName, isLoaded = TRUE)
scriptName |
name of the script for which we want to set the "loaded" state |
isLoaded |
logical. Use |
# If you have a script with the main part on top and the required functions # defined below (as recommended by Robert C. Martin, the author of "Clean # Code") your script may look like this: # Main part ----- # Check if the script has already been loaded (i.e. if setLoaded() has been # called, see end of script). If yes, we can enter the main section. Otherwise # we have to skip the main section since the function sayHello() is not yet # defined. if (isLoaded("welcome")) { sayHello(who = "Hauke") } # Functions ----- sayHello <- function(who) { clearConsole() cat("***\n***\n*** Hello", who, "how are you?\n***\n***\n") } # At the end of your script, call setLoaded() to indicate that your script is # loaded now. If you "source" the script a second time, isLoaded("welcome") # will return TRUE and thus the main section will be entered... setLoaded("welcome")# If you have a script with the main part on top and the required functions # defined below (as recommended by Robert C. Martin, the author of "Clean # Code") your script may look like this: # Main part ----- # Check if the script has already been loaded (i.e. if setLoaded() has been # called, see end of script). If yes, we can enter the main section. Otherwise # we have to skip the main section since the function sayHello() is not yet # defined. if (isLoaded("welcome")) { sayHello(who = "Hauke") } # Functions ----- sayHello <- function(who) { clearConsole() cat("***\n***\n*** Hello", who, "how are you?\n***\n***\n") } # At the end of your script, call setLoaded() to indicate that your script is # loaded now. If you "source" the script a second time, isLoaded("welcome") # will return TRUE and thus the main section will be entered... setLoaded("welcome")
Set matrix columns of given names to fix values
setMatrixColumns(m, columnValuePairs, warn = TRUE)setMatrixColumns(m, columnValuePairs, warn = TRUE)
m |
matrix |
columnValuePairs |
list of elements each of which defines an assignment
in the form |
warn |
if |
Shorten Strings to a Maximum Length
shorten(x, max_chars = 10, delimiter = "...")shorten(x, max_chars = 10, delimiter = "...")
x |
vector of character |
max_chars |
maximum number of characters to which the strings in
|
delimiter |
string to be used as separater between the start and the end
of the strings in |
x with strings longer than max_chars characters being
shortend by replacing characters in the centre by the delimiter
string.
Show Names of Objects/Functions in a Package
showPackageObjects(package = "kwb.utils", show = TRUE)showPackageObjects(package = "kwb.utils", show = TRUE)
package |
name of package of which to show the functions |
show |
if |
source
Load R Scripts with source
sourceScripts(scripts, dbg = TRUE)sourceScripts(scripts, dbg = TRUE)
scripts |
full paths to R scripts |
dbg |
if TRUE (default) log messages ("loading... ok") are shown |
the vector of script paths is returned invisibly
Chain together depth * tabLength spaces
space(depth = 1L, tabLength = 2L)space(depth = 1L, tabLength = 2L)
depth |
depth of indentation |
tabLength |
number of spaces per indentation level |
vector of character of length one consisting of depth *
tabLength space characters
cat(sprintf("%s1\n%s2\n%s3\n", space(1), space(2), space(3))) cat(sprintf("%s1\n%s2\n%s3\n", space(1, 4), space(2, 4), space(3, 4)))cat(sprintf("%s1\n%s2\n%s3\n", space(1), space(2), space(3))) cat(sprintf("%s1\n%s2\n%s3\n", space(1, 4), space(2, 4), space(3, 4)))
Split an array along its n-th dimension. The implementation was found here: https://stackoverflow.com/questions/20198751/three-dimensional-array-to-list
splitAlongDim(a, n)splitAlongDim(a, n)
a |
an array |
n |
number of the dimension along which to split the array |
array of one dimension less than a
# Define an array A <- array(1:8, dim = c(2, 2, 2), dimnames = list( paste0("x", 1:2), paste0("y", 1:2), paste0("z", 1:2) )) splitAlongDim(A, 1) splitAlongDim(A, 2) splitAlongDim(A, 3)# Define an array A <- array(1:8, dim = c(2, 2, 2), dimnames = list( paste0("x", 1:2), paste0("y", 1:2), paste0("z", 1:2) )) splitAlongDim(A, 1) splitAlongDim(A, 2) splitAlongDim(A, 3)
Split a data frame or a matrix into blocks of the same size, i.e. data frames or matrices with the same number of rows (except the last one that is shorter unless the total number of rows is a multiple of the number of rows per block).
splitIntoFixSizedBlocks(data, blocksize)splitIntoFixSizedBlocks(data, blocksize)
data |
data frame or matrix |
blocksize |
number of rows in each block into which |
list of data frames (if data is a data frame) or list of
matrices (if data is a matrix)
Split Text at End of Line Characters Into Lines
splitIntoLines(x)splitIntoLines(x)
x |
vector of character of length 1. |
vector of character as long as there are lines in x
splitIntoLines("a\nb\nc") splitIntoLines("a\r\nb\r\nc")splitIntoLines("a\nb\nc") splitIntoLines("a\r\nb\r\nc")
helper function to convert start indices to end indices
startsToEnds(starts, lastStop, stopOffset = 1)startsToEnds(starts, lastStop, stopOffset = 1)
starts |
vector of integer |
lastStop |
number to be returned as last element of the result vector |
stopOffset |
number to be subtracted from (all but the first elements in) starts in order to find the ends |
vector of integer
starts <- c(1, 10, 20, 35) ok <- identical( startsToEnds(starts, lastStop = 50), c(9, 19, 34, 50) ) ok <- ok && identical( startsToEnds(starts, lastStop = 50, stopOffset = 2), c(8, 18, 33, 50) ) okstarts <- c(1, 10, 20, 35) ok <- identical( startsToEnds(starts, lastStop = 50), c(9, 19, 34, 50) ) ok <- ok && identical( startsToEnds(starts, lastStop = 50, stopOffset = 2), c(8, 18, 33, 50) ) ok
A vector of row numbers is transformed to a data frame describing row ranges by numbers of first and last rows
startsToRanges(starts, lastStop, startOffset = 1, stopOffset = 1)startsToRanges(starts, lastStop, startOffset = 1, stopOffset = 1)
starts |
integer vector of start indices |
lastStop |
integer value of the last stop index |
startOffset |
integer offset applied to the starts |
stopOffset |
integer offsets applied to the ends |
data frame with columns from and to
starts <- c(1, 10, 20, 35) ok <- identical( startsToRanges(starts, lastStop = 50), data.frame( from = c(2, 11, 21, 36), to = c(9, 19, 34, 50) ) ) ok <- ok && identical( startsToRanges(starts, lastStop = 55, startOffset = 2, stopOffset = 2), data.frame( from = c(3, 12, 22, 37), to = c(8, 18, 33, 55) ) ) okstarts <- c(1, 10, 20, 35) ok <- identical( startsToRanges(starts, lastStop = 50), data.frame( from = c(2, 11, 21, 36), to = c(9, 19, 34, 50) ) ) ok <- ok && identical( startsToRanges(starts, lastStop = 55, startOffset = 2, stopOffset = 2), data.frame( from = c(3, 12, 22, 37), to = c(8, 18, 33, 55) ) ) ok
Stop Function Exectution With Formatted Message
stopFormatted(x, ..., call. = FALSE)stopFormatted(x, ..., call. = FALSE)
x |
Error message, possibly containing percentage placeholders, passed
as argument |
... |
as many values as referenced with percentage placeholders in the error message |
call. |
logical, indicating if the call should become part of the error message. |
try(stopFormatted( "Hi, %s, the program fails for the %d-th time.", "Dexter", 1000 ))try(stopFormatted( "Hi, %s, the program fails for the %d-th time.", "Dexter", 1000 ))
Stop with a Message if Input is not a Matrix
stopIfNotMatrix(x)stopIfNotMatrix(x)
x |
object to be checked with |
stringContains
stringContains(x, contains)stringContains(x, contains)
x |
vector of character |
contains |
vector of character |
stringContains(c("abc", "Kabeljau", "Arabella"), "ab") stringContains(c("abc", "Kabeljau", "Arabella"), "abc")stringContains(c("abc", "Kabeljau", "Arabella"), "ab") stringContains(c("abc", "Kabeljau", "Arabella"), "abc")
stringEndsWith
stringEndsWith(x, endsWith)stringEndsWith(x, endsWith)
x |
vector of character to be checked if they end with |
endsWith |
string to be searched for at the end of the string(s) in
|
stringEndsWith(c("abc", "Kabeljau", "Arabella"), "a") stringEndsWith(c("abc", "Kabeljau", "Arabella"), "jau")stringEndsWith(c("abc", "Kabeljau", "Arabella"), "a") stringEndsWith(c("abc", "Kabeljau", "Arabella"), "jau")
Create a string of comma separated quoted strings
stringList(x, qchar = "'", collapse = ", ")stringList(x, qchar = "'", collapse = ", ")
x |
vector of character |
qchar |
character to be used for quoting, default: single quote character |
collapse |
characters used to separate the strings. Default: ", " |
stringStartsWith
stringStartsWith(x, startsWith)stringStartsWith(x, startsWith)
x |
vector of character to be checked if they start with
|
startsWith |
string to be searched for at the beginning of the string(s)
in |
stringStartsWith(c("abc", "Kabeljau", "Arabella"), "ab") stringStartsWith(c("abc", "Kabeljau", "Arabella"), "A")stringStartsWith(c("abc", "Kabeljau", "Arabella"), "ab") stringStartsWith(c("abc", "Kabeljau", "Arabella"), "A")
Convert String to Expression
stringToExpression(expressionString)stringToExpression(expressionString)
expressionString |
character string to be converted to an expression |
Find and Extract Regular Expressions from Strings
subExpressionMatches( pattern, text, match.names = NULL, select = stats::setNames(seq_along(match.names), match.names), simplify = TRUE, regularExpression = NULL )subExpressionMatches( pattern, text, match.names = NULL, select = stats::setNames(seq_along(match.names), match.names), simplify = TRUE, regularExpression = NULL )
pattern |
regular expression containing parts in parentheses that are to be extracted from text |
text |
text to be matched against the regular expression |
match.names |
optional. Names that are to be given to the extracted parts in the result list. |
select |
named vector of numbers specifying the subexpressions in parentheses to be extracted. |
simplify |
if TRUE (default) and text has only one element, the output structure will be a list instead a list of lists |
regularExpression |
deprecated. Use new argument |
If length(text) > 1 a list is returned with as many elements
as there are strings in text each of which is itself a list
containing the strings matching the subpatterns (enclosed in parentheses in
pattern) or NULL for strings that did not match. If
match.names are given, the elements of these lists are named
according to the names given in match.names. If text is of
length 1 and simplify = TRUE (default) the top level list structure
described above is omitted, i.e. the list of substrings matching the
subpatterns is returned.
# split date into year, month and day subExpressionMatches("(\\\\d{4})\\\\-(\\\\d{2})\\\\-(\\\\d{2})", "2014-04-23") # split date into year, month and day (give names to the resulting elements) x <- subExpressionMatches( pattern = "(\\\\d{4})\\\\-(\\\\d{2})\\\\-(\\\\d{2})", "2014-04-23", match.names = c("year", "month", "day") ) cat(paste0("Today is ", x$day, "/", x$month, " of ", x$year, "\n"))# split date into year, month and day subExpressionMatches("(\\\\d{4})\\\\-(\\\\d{2})\\\\-(\\\\d{2})", "2014-04-23") # split date into year, month and day (give names to the resulting elements) x <- subExpressionMatches( pattern = "(\\\\d{4})\\\\-(\\\\d{2})\\\\-(\\\\d{2})", "2014-04-23", match.names = c("year", "month", "day") ) cat(paste0("Today is ", x$day, "/", x$month, " of ", x$year, "\n"))
Substitution of Special Characters
substSpecialChars(x, deuOnly = FALSE)substSpecialChars(x, deuOnly = FALSE)
x |
string containing special characters to be substituted |
deuOnly |
logical. If |
input string x with special characters being substituted by a meaningful represenation or underscore, multiple underscores replaced by a single underscore and multiple underscores at the end removed.
lookup a value in the second column of a data frame x where the value
in the first column matches the key.
tableLookup(x, key, default = NULL)tableLookup(x, key, default = NULL)
x |
data frame with at least two columns. Keys are expected to be in the first and values are expected to be in the second column, respectively. |
key |
key for which a value is to be looked up |
default |
default value that is returned if the key is not a key of the lookup table |
value looked up in the lookup table of default if key is not
contained in the first column of the lookup table x
Create and Return Path to Subdirectory in tempdir()
tempSubdirectory(..., dbg = FALSE)tempSubdirectory(..., dbg = FALSE)
... |
parts of path to be created below |
dbg |
if |
full path to created directory
tempSubdirectory("my-folder/my-subfolder")tempSubdirectory("my-folder/my-subfolder")
Convert Text Representation Back to R Object
textToObject(x)textToObject(x)
x |
vector of character as returned by |
R object
textToObject("c(1:10)") stopifnot(identical(iris, textToObject(objectToText(iris))))textToObject("c(1:10)") stopifnot(identical(iris, textToObject(objectToText(iris))))
Convert Function to Function that is Called if Condition is Met
toConditional(FUN)toConditional(FUN)
FUN |
a function |
square <- function(x) x^2 negate <- function(x) -x `%>%` <- magrittr::`%>%` do_square <- TRUE do_negate <- TRUE 10 %>% toConditional(square)(do_square) %>% toConditional(negate)(do_negate)square <- function(x) x^2 negate <- function(x) -x `%>%` <- magrittr::`%>%` do_square <- TRUE do_negate <- TRUE 10 %>% toConditional(square)(do_square) %>% toConditional(negate)(do_negate)
In contrast to the default behaviour of base::as.factor, this function
uses the unsorted unique values of x as levels and not sorted unique
values.
toFactor(x)toFactor(x)
x |
vector to be converted to factor |
x <- c("b", "c", "a") as.factor(x) # Levels: a b c toFactor(x) # Levels: b c ax <- c("b", "c", "a") as.factor(x) # Levels: a b c toFactor(x) # Levels: b c a
create a formula of the form leftterm ~ rightterms[1] + rightterms[2] +
...
toFormula(leftterm, rightterms, as.formula = TRUE)toFormula(leftterm, rightterms, as.formula = TRUE)
leftterm |
character. Left term of the formula |
rightterms |
vector of character. Right terms of the formula to be concatenated with "+". |
as.formula |
if TRUE (default) the formula object is returned, otherwise the formula string (character) |
formula object as generated by formula or formula string
(character) of the form leftterm ~ rightterms[1] +
rightterms[2] + ... if as.formula is FALSE
f1 <- toFormula("y", c("x1", "x2")) f2 <- toFormula("y", paste0("x", 1:20)) f3 <- toFormula("BMI", c("height", "mass"), as.formula = FALSE) # f1 and f2 are formulas ... class(f1) class(f2) # ... but f3 is just "character" class(f3)f1 <- toFormula("y", c("x1", "x2")) f2 <- toFormula("y", paste0("x", 1:20)) f3 <- toFormula("BMI", c("height", "mass"), as.formula = FALSE) # f1 and f2 are formulas ... class(f1) class(f2) # ... but f3 is just "character" class(f3)
Convert Centimeters to Inches
toInches(cm)toInches(cm)
cm |
vector of numeric representing length(s) in cm |
vector of numeric representing length(s) in inches
Converts a string of the form "a=1,b=2" to a list with elements
keys (here: c("a", "b")) and values (here: (1,2)).
toKeysAndValues(x, separators = c(",", "="))toKeysAndValues(x, separators = c(",", "="))
x |
character vector of length 1 |
separators |
character vector of length 2 representing two types of
separators. The first (default: ",") is used to split |
list with elements keys and values
Provide the mapping between keys and values in a structure of choice
toLookupClass( keys, values, class = c("data.frame.1", "data.frame.2", "list", "vector")[1] )toLookupClass( keys, values, class = c("data.frame.1", "data.frame.2", "list", "vector")[1] )
keys |
vector of keys |
values |
vector of values |
class |
character string determining the class of the structure
returned: "data.frame.1": data frame with the |
object according to the chosen class. See description of the
class argument.
keys <- c("A", "B", "C") values <- c("Apple", "Banana", "Cherry") fruits.df1 <- toLookupClass(keys, values) fruits.df2 <- toLookupClass(keys, values, class = "data.frame.2") fruits.list <- toLookupClass(keys, values, class = "list") fruits.vector <- toLookupClass(keys, values, class = "vector") # Note how you may use the results differently fruits.df1$A fruits.list$A fruits.vector["A"] fruits.df1[c("A", "C")] fruits.list[c("A", "C")] fruits.vector[c("A", "C")]keys <- c("A", "B", "C") values <- c("Apple", "Banana", "Cherry") fruits.df1 <- toLookupClass(keys, values) fruits.df2 <- toLookupClass(keys, values, class = "data.frame.2") fruits.list <- toLookupClass(keys, values, class = "list") fruits.vector <- toLookupClass(keys, values, class = "vector") # Note how you may use the results differently fruits.df1$A fruits.list$A fruits.vector["A"] fruits.df1[c("A", "C")] fruits.list[c("A", "C")] fruits.vector[c("A", "C")]
Keys and values to lookup list (list with elements representing the values and the names of the list elements representing the corresponding keys)
toLookupList(keys, values, data = NULL)toLookupList(keys, values, data = NULL)
keys |
vector of character representing the keys of the dictionary |
values |
vector of character representing the values of the dictionary |
data |
Optional. Data frame with two columns of which the first is assumed to contain the keys and the second is assumed to contain the values of the dictionary |
dictionary: list with values as elements and keys as names
Convert vectors of keys and values or a list into a lookup table (data frame)
toLookupTable( keys = NULL, values = NULL, List = NULL, as.twoColumnTable = FALSE, stringsAsFactors = FALSE )toLookupTable( keys = NULL, values = NULL, List = NULL, as.twoColumnTable = FALSE, stringsAsFactors = FALSE )
keys |
keys of the lookup table |
values |
values of the lookup table |
List |
list of named elements with the names representing the keys and the values representing the values of the lookup table |
as.twoColumnTable |
if TRUE (the default is FALSE) the result is a data frame with two columns keys and values, respectively. |
stringsAsFactors |
passed to |
data frame with one row containing values in columns named
keys or, if as.twoColumnTable = TRUE, a data frame with the
keys in column key and the values in column
value
Convert to List with Names Equal to List Elements
toNamedList(x)toNamedList(x)
x |
R object, preferably vector of character |
result of calling as.list on x with list element names
being set to the elements of x.
x.vector <- c("Peter", "Paul", "Mary") x.list <- toNamedList(x.vector) all(names(x.list) == x.vector) # You may use toNamedList in a call of lapply in order to get a named result lapply(toNamedList(x.vector), function(x) sprintf("Hello, %s", x)) # Compare with lapply(x.vector, function(x) sprintf("Hello, %s", x))x.vector <- c("Peter", "Paul", "Mary") x.list <- toNamedList(x.vector) all(names(x.list) == x.vector) # You may use toNamedList in a call of lapply in order to get a named result lapply(toNamedList(x.vector), function(x) sprintf("Hello, %s", x)) # Compare with lapply(x.vector, function(x) sprintf("Hello, %s", x))
The function opens a PDF device with pdf, executes the given
expressions, closes the PDF file and displays the file in a PDF viewer.
toPdf(expressions, pdfFile = NULL, ...)toPdf(expressions, pdfFile = NULL, ...)
expressions |
R expressions creating plots that are to be redirected into a pdf file. You may pass multiple expressions within opening and closing curly braces |
pdfFile |
optional. Path to the PDF file to be created. The directory
part of the path must exist. If not given or |
... |
further arguments passed to |
The function returns the path to the created PDF file.
## Not run: toPdf({ plot(1:10, 10:1) barplot(1:10) hist(rnorm(100)) }) ## End(Not run)## Not run: toPdf({ plot(1:10, 10:1) barplot(1:10) hist(rnorm(100)) }) ## End(Not run)
Convert negative indices to positive indices where negative indices are interpreted as indices counting from the back of the vector
toPositiveIndices(indices, n)toPositiveIndices(indices, n)
indices |
vector of integer indices |
n |
maximum index. The index -1 is mapped to |
Replace underscore with percent sign. May be used to define time format strings as defaults in function declarations which are not supported by inlinedocs.
underscoreToPercent(x)underscoreToPercent(x)
x |
character vector containing underscores |
Unique Directory Names
uniqueDirnames(x)uniqueDirnames(x)
x |
vector of file paths |
vector of character with the unique directories found in x
uniqueDirnames(c("a/b", "a/c", "b/c", "b/d"))uniqueDirnames(c("a/b", "a/c", "b/c", "b/d"))
Split a data frame z into two data frames x and y so
that merge(x, y) is z.
unmerge(z, by)unmerge(z, by)
z |
data frame |
by |
vector of names of columns in |
list with two elements x and y each of which are data
frames containing at least the columns given in by.
z <- data.frame( name = c("peter", "peter", "paul", "mary", "paul", "mary"), age = c(42, 42, 31, 28, 31, 28), height = c(181, 181, 178, 172, 178, 172), subject = c("maths", "bio", "bio", "bio", "chem", "maths"), year = c(2016, 2017, 2017, 2017, 2015, 2016), mark = c("A", "B", "B", "A", "C", "b") ) # What fields seem to be properties of objects identified by name? # -> Age and height are fix properties of the persons identified by name (result1 <- unmerge(z, "name")) # What fields seem to be properties of objects identified by subject? # -> It seems that the subjects have been tested in different years (result2 <- unmerge(z, "subject")) # Test if merge(result$x, result$y) results in z y1 <- merge(result1$x, result1$y) y2 <- merge(result2$x, result2$y) columns <- sort(names(z)) identical(fullySorted(z[, columns]), fullySorted(y1[, columns])) # TRUE identical(fullySorted(z[, columns]), fullySorted(y2[, columns])) # TRUEz <- data.frame( name = c("peter", "peter", "paul", "mary", "paul", "mary"), age = c(42, 42, 31, 28, 31, 28), height = c(181, 181, 178, 172, 178, 172), subject = c("maths", "bio", "bio", "bio", "chem", "maths"), year = c(2016, 2017, 2017, 2017, 2015, 2016), mark = c("A", "B", "B", "A", "C", "b") ) # What fields seem to be properties of objects identified by name? # -> Age and height are fix properties of the persons identified by name (result1 <- unmerge(z, "name")) # What fields seem to be properties of objects identified by subject? # -> It seems that the subjects have been tested in different years (result2 <- unmerge(z, "subject")) # Test if merge(result$x, result$y) results in z y1 <- merge(result1$x, result1$y) y2 <- merge(result2$x, result2$y) columns <- sort(names(z)) identical(fullySorted(z[, columns]), fullySorted(y1[, columns])) # TRUE identical(fullySorted(z[, columns]), fullySorted(y2[, columns])) # TRUE
Get the name of the current user from the environment variables
user(osType = .OStype())user(osType = .OStype())
osType |
Optional. Type of operating system, one of |
character string represenging the name of the current user
Gives a warning if the object is NULL or empty and returns the object
warnIfEmpty(x)warnIfEmpty(x)
x |
object to be tested for NULL or being empty (vector of length 0 or data frame with no rows) |
Create Warning About a Deprecated Function
warningDeprecated(old_name, new_name, parentheses = TRUE)warningDeprecated(old_name, new_name, parentheses = TRUE)
old_name |
name of deprecated function |
new_name |
name of new function to be used instead |
parentheses |
logical. Should parentheses be printed after the names
in the output? Default: |
## Not run: warningDeprecated("old_function()", "new_function()") ## End(Not run)## Not run: warningDeprecated("old_function()", "new_function()") ## End(Not run)
create MS Windows-compatible path by substituting forward slashes with backslashes
windowsPath(path)windowsPath(path)
path |
vector of character representing file paths |
Write a Dictionary (List) to a Text File
writeDictionary(dictionary, file)writeDictionary(dictionary, file)
dictionary |
list of character vectors of length one defining |
file |
full path to the file to which |
readDictionary, readDictionaries
Write text to a file using writeLines and output a debug
message by default
writeText(x, file, type = "", dbg = TRUE, ...)writeText(x, file, type = "", dbg = TRUE, ...)
x |
vector of character representing the lines to be written to
|
file |
path to file to be written, passed to |
type |
character string to be included in the debug message: "Writing <type>'file-path' ..." |
dbg |
if |
... |
further arguments passed to |
This function invisibly returns the path to the output file.
# Define text to be written to file x <- c("Hello", "world") # Write text to a temporary file and catch the file path file <- writeText(x, tempfile(fileext = ".txt")) # Make the debug message more informative writeText(x, file, type = "welcome file") # Read lines back and show on the console catLines(readLines(file))# Define text to be written to file x <- c("Hello", "world") # Write text to a temporary file and catch the file path file <- writeText(x, tempfile(fileext = ".txt")) # Make the debug message more informative writeText(x, file, type = "welcome file") # Read lines back and show on the console catLines(readLines(file))