listcompr (version 0.2.0)

gen.list: Generate Lists, Vectors and Data Frames with List Comprehension

Description

Functions to transform a base expression containing free variables into a list, a vector, or a data frame based on variable ranges and additional conditions.

Usage

gen.list(expr, ...)
gen.vector(expr, ...)
gen.data.frame(expr, ...)

Arguments

expr

A base expression containing free variables which is evaluated for all combinations of variables, where the combinations of variables are given by the ranges and conditions (see ... parameters).

Expected structure of expr:

• For gen.list it may have arbitrary structure (including a list).

• For gen.vector a value (i.e., a vector of length 1) is expected.

• For gen.data.frame a (named) vector or list is expected which describes one row of the data frame.

Within expr it is allowed to use functions and predefined constants from the parent environment.

...

Arbitrary many variable ranges and conditions. For all free variables occurring in expr a range must be assigned, e.g., x = 1:3, y = 1:5 for an expression x + y. At least one variable range is required. The ranges may depend on each other, e.g., x = 1:3, y = x:3 or a substitution like x = 1:3, y = 2 * x is allowed. The generated values can be further restricted by conditions (like x <= y).

Value

The result of gen.list is a list (a vector for gen.vector) containing an entry for each combination of the free variables (i.e., the Cartesian product), where all the free variables in expr are substituted. The function gen.vector returns a vector while gen.list may contain also more complex substructures (like vectors or lists).

The output of gen.data.frame is a data frame where each substituted expr entry is one row. The base expression expr should contain a (named) vector or list, such that each entry of this vector becomes a column of the returned data frame. If the vector contains a single literal without a name, this is taken as column name. For instance, gen.data.frame(a, a = 1:5) returns the same as gen.data.frame(c(a = a), a = 1:5). Default names 'V1', 'V2', ... are used, if no names are given and names can't be automatically detected.

All expressions and conditions are applied to each combination of the free variables separately, i.e., they are applied row-wise and not vector-wise. For instance, the term sum(x,y) (within expr or a condition) is equivalent to x+y.

Syntactic Features

There are several syntactic features to be used in variable ranges, conditions, and expressions.

A range for a variable ending with an underscore (like x_) defines a set of ranges affecting all variables named {varname}_{index}, e.g. x_1. For instance, in gen.vector(x_1 + x_2 + x_3, x_ = 1:5) the variables x_1, x_2, x_3 are all ranging in 1:5. This can be overwritten for each single x_i, e.g., an additional argument x_3 = 1:3 assigns the range 1:3 to x_3 while x_1 and x_2 keep the range 1:5. A group of indexed variables is kept always sorted according to the position of the main variable {varname}_. For instance, the two following statements produce the same results:

• gen.vector(x_1 + x_2 + a, x_ = 1:5, a = 1:2, x_1 = 1:2)

• gen.vector(x_1 + x_2 + a, x_1 = 1:2, x_2 = 1:5, a = 1:2)

Expressions and conditions support a ...-notation which works as follows:

• A vector like c(x_1, ..., x_4) is a shortcut for c(x_1, x_2, x_3, x_4).

• A named vector like c(a_1 = x_1, ..., a_3 = x_3) is a shortcut for c(a_1 = x_1, a_2 = x_2, a_3 = x_3).

• A n-ary function argument like sum(x_1, ..., x_4) is a shortcut for sum(x_1, x_2, x_3, x_4).

• Repeated expressions of binary operators can be abbreviated with the ... expressions as follows: x_1 + ... + x_4 is a shortcut for x_1 + x_2 + x_3 + x_4. Note that, due to operator precedence, 1 + x_1 + ... + x_4 will not work, but 1 + (x_1 + ... + x_4) works as expected.

• For non-commutative operators, x_1 - ... - x_4 is a shortcut for x_1 - x_2 - x_3 - x_4 which is evaluated as ((x_1 - x_2) - x_3) - x_4.

The conditions may contain itself list comprehension expressions, e.g., gen.logical.and to compose and-connected logical expressions.

See Also

gen.list.expr to generate expressions to be evaluated later, gen.list.char to generate lists of characters, and listcompr for an overview of all list comprehension functions.

Examples

# NOT RUN {
# Compose 10, 11, 20, 21, 22, 30, ..., 33, ..., 90, ..., 99 into a vector
gen.vector(x * 10 + y, x = 1:9, y = 1:x)

# A list containing vectors [1], [1, 2], [1, 2, 3], ...
gen.list(gen.vector(i, i = 1:n), n = 1:10)

# A data frame of tuples (x_1, x_2, x_3) summing up to 10
gen.data.frame(c(x_1, ..., x_3), x_ = 1:10, x_1 + ... + x_3 == 10)

# A data.frame containing the numbers in 2:20, the sum of their divisors
# and a flag if they are "perfect" (sum of divisors equals the number)
gen.data.frame(c(n, sumdiv, perfect = (n == sumdiv)), n = 2:20, 
               sumdiv = sum(gen.vector(x, x = 1:(n-1), n %% x == 0)))

# }