Package 'exams.forge'

Description

The exams.forge package was created with the main goal of "forging" exam tasks in combination with the exams package, and it includes additional functions to simplify the creation of Moodle exercises. The package features various functions categorized into seven groups based on their characteristics. These categories are named: Data Conversion and Modification, Statistical Analysis, Mathematical Computations, Exercise Generation, String Manipulation, LaTeX and HTML Functions, and General Purpose Functions.

Details

This package is designed for educators who need to develop examination materials in the field of statistics, particularly for introductory courses like Statistics I and II, using the R programming language. The aim is to streamline the process of creating a large number of assessment items, enabling instructors to focus on improving the quality of the tasks themselves.

We would like to acknowledge the support provided by the Multimedia Funding Program. Their assistance has been invaluable to our project, and we extend our sincere gratitude for their contributions.

Features of the package

• Feature 1: exams.forge simplifies the generation of examination tasks by providing tools to create a diverse array of statistical exercises, ensuring unique problem sets for each student.

• Feature 2: It includes functions for precise data conversion, statistical analysis, and mathematical computations, enhancing the accuracy and relevance of generated exercises.

• Feature 3: The package supports multi-format rendering, allowing the seamless creation of LaTeX and HTML documents suitable for various educational platforms, such as Moodle.

Functions

Examples of functions included in the package:

• ts_data: Creates a univariate time series by combining elements of a linear or exponential trend, additive or multiplicative seasonal adjustment, and white noise. The resulting time series is structured as a ⁠ts_data object⁠, allowing for further analysis and exploration.

• lmatrix: Creates a LaTeX or HTML representation of a matrix. This function is useful for integrating well-formatted matrices into LaTeX or HTML documents.

• as_obs: Creates a string representing observations with optional sorting and LaTeX formatting, useful for generating readable data representations in educational materials.

Usage

Example usage of the package and its functions.

library(exams.forge) # Generate a time series with specified parameters ts_eg <- ts_data(end = 20, trend = TRUE, trend.coeff = c(1, 0.5), season = TRUE, season.coeff = c(0.2, 0.1), error = TRUE, error.coeff = 0.1, digits = 2) print(ts_eg)

# Create a matrix mx_data <- matrix(1:6, ncol = 2) # Generate a LaTeX representation of the matrix with tooltip eg_matrix <- lmatrix( m = mx_data, title = "Example LaTeX Matrix", fmt = " byrow = TRUE, tooltip = "Die Tabelle hat cat(eg_matrix)

# Create a string representation of observations observations <- c(10, 20, 30, 40, 50) observation_string <- as_obs(observations, last = " and ") print(observation_string)

Installation

To install this package please use the following command: install.packages("exams.forge")

Author(s)

Sigbert Klinke, Affiliation: Humboldt University of Berlin, School of Business and Economics, Chair of Statistics.

Maintainer

Sigbert Klinke [email protected]

License

Gnu General Public License 3.

Author(s)

Maintainer: Sigbert Klinke [email protected] (ORCID)

Other contributors:

• Kleio Chrysopoulou Tseva [email protected] [contributor]

Description

Generates and appends additional random values to the left and/or right ends of a numeric vector x. The range from which these values are drawn is determined by a specified "box" and a scaling factor.

Usage

add_data(x, box, n = c(0, 1), range = c(0, 1))

Arguments

Details

The "box" defines the central range of the data and can be:

• "boxplot" — uses the 25th and 75th percentiles (quantile(x, c(0.25, 0.75), na.rm = TRUE)).

• "range" — uses the full range of the data (range(x, na.rm = TRUE)).

• A numeric vector of length two — used directly as the box boundaries.

The box length is the distance between the lower and upper box boundaries. The range parameter specifies how far left or right new values can be drawn, as a multiple of the box length.

For the left side, values are drawn uniformly from:

$[ \text{box[1]} - \text{range[2]} \times \text{box length},\; \text{box[1]} - \text{range[1]} \times \text{box length} ]$

For the right side, values are drawn uniformly from:

$[ \text{box[2]} + \text{range[1]} \times \text{box length},\; \text{box[2]} + \text{range[2]} \times \text{box length} ]$

The n parameter controls how many values are added:

• Single number — adds that many values to the right side only.

• Length-two vector — n[1] values to the left, n[2] values to the right.

Value

A numeric vector containing the original values from x plus the newly generated values.

Examples

x <- rnorm(8)

# Add one value to the right
add_data(x, "box", range = 1.5)

# Add one value to the right using data range
add_data(x, "range", range = 0.1)

# Add one value to the right, larger possible range
add_data(x, "box", range = c(1.5, 3))

# Add two values to the right
add_data(x, "range", n = 2, range = 0.1)

# Add two values to the left and three to the right
add_data(x, "range", n = c(2, 3), range = 0.1)

Description

A set of helper functions for adding or removing specific prefixes and/or suffixes to character vectors. This is useful for formatting strings in mathematical, XML, or other structured text contexts.

• affix() – Add any prefix and/or suffix to each element of a character vector; alias: add_affix().

• math() – Add a dollar sign ($) to both ends of each element (LaTeX-style math); aliases: add_math(), lmath().

• bracket() – Wrap each element in parentheses; aliases: add_bracket(), brkt().

• cdata() – Wrap each element in ⁠<![CDATA[ ... ]]>⁠ (XML CDATA section); alias: add_cdata().

• unaffix() – Remove a given prefix and/or suffix from each element; alias: remove_affix().

• unquote() – Remove surrounding double quotes from each element; alias: remove_quotes().

• uncdata() – Remove a surrounding CDATA section from each element.; alias: remove_cdata().

Usage

affix(txt, prefix = "", suffix = "")

math(txt)

bracket(txt)

unaffix(txt, prefix = "", suffix = "")

unquote(txt)

uncdata(txt)

cdata(txt)

add_affix(txt, prefix = "", suffix = "")

add_cdata(txt)

add_math(txt)

lmath(txt)

add_bracket(txt)

brkt(txt)

remove_affix(txt, prefix = "", suffix = "")

remove_quotes(txt)

remove_cdata(txt)

Arguments

Value

A modified character vector of the same length as txt.

Examples

x <- c("alpha", "beta", "gamma")

# Add a prefix and suffix
affix(x, "[", "]")
#> [1] "[alpha]" "[beta]" "[gamma]"

# Wrap with LaTeX math delimiters
math(x)
#> [1] "$alpha$" "$beta$" "$gamma$"

# Remove quotes
quoted <- c('"a"', '"b"')
unquote(quoted)
#> [1] "a" "b"

# Wrap and unwrap CDATA
cdata_x <- cdata("text")
uncdata(cdata_x)

Description

These functions determine whether numeric values are sufficiently different from each other based on a specified tolerance.

• all_different: Checks if all differences between entries in a numeric object exceed a given tolerance.

• values_different: Adds candidate values to a set of initial values only if they are sufficiently different from all existing values.

Usage

all_different(obj, tol)

values_different(values, candidates, tol = 0.1)

Arguments

Value

• all_different: Logical (TRUE if all differences exceed tol, FALSE otherwise).

• values_different: Numeric vector with original values plus any candidates that meet the difference criterion.

Examples

# Check if all values are sufficiently different
x <- runif(10)   # 10 random values between 0 and 1
all_different(x, tol = 0.01)
all_different(x, tol = 0.5)

# Add sufficiently different candidate values
starting_values <- c(0.1, 0.5, 0.9)
candidates <- c(0.15, 0.4, 0.8, 1.2)
values_different(starting_values, candidates, tol = 0.2)

Description

Rounds x according to digits and the rounding function FUN, and sets a tolerance for the result. If tol is not provided, it defaults to 2*10^(-digits).

Usage

as_result(x, digits, tol = NA, FUN = round2)

tol(x)

rounded(x)

val(x)

digits(x)

as_res(x, digits, tol = NA, FUN = round2)

tolerance(x)

Arguments

Details

Results with Rounding

Creates a structured result with a numeric value rounded according to specified digits, an optional tolerance, and a rounding function.

By default, rounding is performed using an internal function round2(), which is similar to exams::round2(), but users should not call it directly. You can also supply a custom rounding function via the FUN argument.

If digits is a character, the following abbreviations are recognized:

"integer"

digits = 0

"%"

digits = 2

"probability"

digits = 4

Partial matching of these names is allowed.

Value

A list of class result containing:

Examples

x <- as_result(1/3, "probability")
tol(x)
rounded(x)
digits(x)

Description

These functions convert vectors into human-readable string representations. They can join elements, create LaTeX-formatted fractions, or label observations.

Usage

as_string(txt, collapse = ", ", last = ", and ")

as_sum(txt)

as_obs(txt, name = "x", sorted = FALSE, ...)

as_fraction(val, latex = FALSE, sorted = FALSE, ...)

lobs(txt, name = "x", sorted = FALSE, ...)

lstring(txt, collapse = ", ", last = ", and ")

lfrac(val, latex = FALSE, sorted = FALSE, ...)

Arguments

Value

A single string, or a vector of formatted strings (for fractions in as_fraction).

Examples

x <- runif(5)
y <- c(TRUE, FALSE, NA)

# Basic string conversion
as_string(x)
as_string(y)
as_string(as.character(x))
as_string(as.character(y))

# Observations
as_obs(x)
as_obs(sort(x), sorted = TRUE)

# Fraction conversion
x <- round(runif(5), 2)
as_fraction(x)
as_fraction(x, latex = TRUE)

# Summing elements as a string
y <- round(runif(5), 2)
as_sum(y)

Description

Converts a vector or matrix into a formatted horizontal table using xtable. The output is returned as a character vector, where each element corresponds to a line of the table, suitable for printing or further formatting.

Usage

as_table(
  x,
  caption = NULL,
  label = NULL,
  align = NULL,
  digits = NULL,
  display = NULL,
  auto = FALSE,
  ...
)

toTable(
  x,
  caption = NULL,
  label = NULL,
  align = NULL,
  digits = NULL,
  display = NULL,
  auto = FALSE,
  ...
)

Arguments

Details

Convert a Vector or Matrix to a Horizontal Table

Value

A character vector, each element representing a line of the table.

Examples

x <- runif(5)
tab <- vec2mat(x, colnames = 1:length(x))
as_table(tab)

Description

Transforms a ts_data object into a standard R ts (time series) object.

Usage

as_ts(ts)

Arguments

Details

The function preserves the original time indices and frequency of the input ts_data. It calculates the deltat based on the time vector t in ts_data.

Value

A ts object representing the same time series as the input ts_data.

Examples

# Create a ts_data object with a linear trend
ts_obj <- ts_data(12, trend.coeff = c(sample(0:10, 1), sample(1 + (1:10)/20, 1)))

# Convert to standard ts object
ts_standard <- as_ts(ts_obj)

Description

Compute association and correlation measures for categorical and ordinal data.

The following measures are implemented:

• nom.cc: Corrected contingency coefficient for nominal data.

• nom.cramer: Cramer's V (or Phi) for nominal data.

• ord.spearman: Spearman's rank correlation for ordinal data.

• ord.kendall: Kendall's rank correlation for ordinal data.

Usage

nom.cc(tab, correct = FALSE)

nom.cramer(tab, ...)

ord.spearman(tab, ...)

ord.kendall(tab, ...)

cc_coef(tab, correct = FALSE)

cramer_vf(tab, ...)

cramer_coef(tab, ...)

kendall_corr(tab, ...)

spearman_corr(tab, ...)

rs_corr(tab, ...)

Arguments

Details

These functions provide common measures of association:

• Nominal data: nom.cc, nom.cramer.

• Ordinal data: ord.spearman, ord.kendall.

Value

A numeric value representing the association or correlation measure.

Examples

# Create a random contingency table
tab <- matrix(round(10 * runif(15)), ncol = 5)

# Nominal association
nom.cc(tab)
nom.cc(tab, correct = TRUE)
nom.cramer(tab)

# Ordinal correlation
ord.spearman(tab)
ord.kendall(tab)

# Using aliases
cc_coef(tab)
cramer_vf(tab)
spearman_corr(tab)
kendall_corr(tab)
rs_corr(tab)

Description

Reorders the entries of a frequency table to approximate a given target association or correlation.

The reordering preserves the marginal frequencies of the table. Note that the target association may not always be achievable, especially for extreme values (e.g., +1, -1, or values near these limits).

Usage

assoc_data(
  tab,
  zero = FALSE,
  FUN = nom.cc,
  target = NA,
  tol = 0.001,
  maxit = 500,
  ...
)

reorder_association_data(
  tab,
  zero = FALSE,
  FUN = nom.cc,
  target = NA,
  tol = 0.001,
  maxit = 500,
  ...
)

dassoc(
  tab,
  zero = FALSE,
  FUN = nom.cc,
  target = NA,
  tol = 0.001,
  maxit = 500,
  ...
)

Arguments

Details

The function attempts to reorder the table entries to reach the target association. If the target is extreme (e.g., +1, -1, or values near these limits), a solution may not be possible. If attr(joint, "iterations") equals maxit, consider increasing maxit, reducing tol, or choosing a more feasible target value:

• Nominal measures: $0 \le target \le 1$

• Ordinal measures: $-1 \le target \le +1$

Value

A frequency table reordered to approximate the target association. The returned object includes attributes:

iterations

Number of iterations performed.

target

Achieved association or correlation value.

Examples

tab <- table_data(3, 2)
tab
tab2 <- assoc_data(tab, target = 0.5)
tab2

Description

Creates a data frame of possible combinations of n (number of trials) and p (probabilities) that satisfy specified constraints on the mean, standard deviation, and approximation conditions for normal or Poisson distributions.

The function applies the following rules:

• If length(mean) == 1 and it is an integer, it specifies the number of digits to which the mean should be rounded.

• If mean = NA (default), all mean values are allowed.

• If length(mean) > 1, only combinations where n * p equals one of the specified means are retained.

• The same logic applies to sd for the standard deviation.

The norm and pois arguments can be logical, NA, or a custom function of the form ⁠function(n, p)⁠. They control which ⁠(n, p)⁠ pairs are considered valid:

• NA allows all combinations.

• A function returns TRUE for valid combinations and FALSE for invalid ones.

• TRUE enforces standard approximation rules:

  • norm: n * p * (1 - p) > 9 (normal approximation condition)

  • pois: n > 10 & p < 0.05 (Poisson approximation condition)

• FALSE excludes combinations that meet the approximation condition.

Note: The resulting data frame may be empty if no combinations meet all criteria.

Usage

binom_param(n, p, mean = NA, sd = NA, norm = NA, pois = NA, tol = 1e-06)

Arguments

Value

A data frame with columns n, p, mean, and sd representing valid parameter combinations.

Examples

binom_param(1000:50000, (5:25)/100, mean = 0, sd = 0)

Description

Creates a numeric vector of break points for the given data x. The resulting breaks define bins that are either equidistant (fixed width) or non-equidistant (quantile-based). If width is not specified, it defaults to diff(pretty(x))[1]. The probs argument can either be a single integer, specifying the number of quantiles, or a numeric vector of probabilities in the interval $[0, 1]$.

Usage

breaks(x, width = NULL, probs = NULL)

add_breaks(x, width = NULL, probs = NULL)

dbreaks(x, width = NULL, probs = NULL)

Arguments

Details

If probs is used, break points are rounded to the nearest multiple of width. Duplicates are removed, and the range is extended if necessary to include the full range of x.

Value

A numeric vector containing the break points.

Examples

x <- rnorm(100, mean = 1.8, sd = 0.1)
breaks(x)                # equidistant bins
breaks(x, width = 0.1)   # custom width bins
breaks(x, width = 0.1, probs = 4)  # quantile-based bins

Description

Determines whether the current function call was initiated by a specified function. This is useful for conditional behavior depending on the caller.

Usage

calledBy(fun = "exams2pdf")

called_by(fun = "exams2pdf")

Arguments

Value

A logical value: TRUE if the current call was triggered by fun, otherwise FALSE.

Examples

funB <- function() { calledBy("funA") }
funA <- function() { funB() }
funA()  # Returns TRUE because funB was called by funA

Description

Prints text using cat only when a specified logical condition is TRUE.

Usage

catif(cond, ...)

condition_cat(cond, ...)

Arguments

Value

Invisibly returns the value of cond.

Examples

catif(TRUE, "PDF")          # This text is printed
catif(FALSE, "Moodle")      # Nothing is printed
condition_cat(TRUE, "Hello") # Alias works the same way

Description

Computes confidence intervals for a population mean (mu) using either supplied data or data generated from a normal distribution with specified parameters. The function calculates key statistics such as the sample mean, standard deviation, and confidence intervals at user-defined confidence levels. Results are returned as a structured list containing observed and/or theoretical values, interval endpoints, and related measures.

Usage

CImu_data(
  x = NULL,
  n = length(x),
  xbar = NULL,
  sd = NULL,
  conf.level = c(0.9, 0.95, 0.99),
  mu = NULL,
  sigma = NULL
)

dcimu(
  x = NULL,
  n = length(x),
  xbar = NULL,
  sd = NULL,
  conf.level = c(0.9, 0.95, 0.99),
  mu = NULL,
  sigma = NULL
)

Arguments

Value

A list containing:

Examples

# Using observed data
x <- rnorm(100)
CImu_data(x, conf.level = 0.95)

# Simulating data internally
CImu_data(n = 100, conf.level = 0.95, mu = 0, sigma = 1)

Description

Data generation for the necessary sample size of a confidence interval, for the population mean value. Either the estimation error $e$ or the length of the interval $l$ must be given ($l=2*e$). It is ensured that the computed s deviates from sigma.

Usage

CImulen_data(
  sigma,
  e = NULL,
  l = NULL,
  conf.level = c(0.9, 0.95, 0.99),
  nmin = 30,
  size = NA,
  u = c(seq(0.1, 0.4, 0.001), seq(0.6, 0.9, 0.001)),
  full = FALSE
)

dcimulen(
  sigma,
  e = NULL,
  l = NULL,
  conf.level = c(0.9, 0.95, 0.99),
  nmin = 30,
  size = NA,
  u = c(seq(0.1, 0.4, 0.001), seq(0.6, 0.9, 0.001)),
  full = FALSE
)

Arguments

Value

A data frame or a list with:

• $e$: estimation error

• sigma: population variance

• conf.level: confidence level

• $l$: interval length

• x: $1-alpha/2$

• q: $z_{1-alpha/2}$

• q2: $z^2_{1-alpha/2}$

• n: computed minimal sample size

• N: the smallest integer, no less than n

• s: sample standard deviation

Examples

# one solution
CImulen_data (1:10, e=(1:10)/10)
# all solutions
mul <- CImulen_data (1:10, e=(1:10)/10, full=TRUE)
str(mul)

Description

Data generation for the necessary sample size of a confidence interval, for the population proportion, using $z^2/l^2)$. Either the estimation error $e$ or the length of the interval $l$ must be given ($l=2*e$). It is ensured that the computed p deviates from pi.

Usage

CIpilen_data(
  pi,
  e = NULL,
  l = NULL,
  conf.level = c(0.9, 0.95, 0.99),
  nmin = 30,
  size = NA,
  u = c(seq(0.1, 0.4, 0.001), seq(0.6, 0.9, 0.001)),
  full = FALSE
)

dcipilen(
  pi,
  e = NULL,
  l = NULL,
  conf.level = c(0.9, 0.95, 0.99),
  nmin = 30,
  size = NA,
  u = c(seq(0.1, 0.4, 0.001), seq(0.6, 0.9, 0.001)),
  full = FALSE
)

Arguments

Value

A data frame or a list with:

• $e$ estimation error

• pi population proportion

• conf.level confidence level

• $l$ interval length

• x $1-alpha/2$

• q $z_{1-alpha/2}$

• q2 $z^2_{1-alpha/2}$

• n computed minimal sample size

• N the smallest integer, no less than n

• p sample proportion

Examples

# one solution
CIpilen_data((1:9/10), (1:9)/10)
# all solutions
pil <- CIpilen_data((1:9/10), (1:9)/10, full=TRUE)
str(pil)

Description

Deletes a file immediately after a specified delay or schedules it for deletion when the R session ends.

Usage

cleanFile(file, delay)

Arguments

Value

Invisibly returns the file path.

Examples

{ # Delete a temporary file after 2 seconds
  tmp <- tempfile(); 
  if (file.create(tmp)) cleanFile(tmp, delay = 1)
  # Keep a temporary file until the R session ends
  tmp2 <- tempfile()
  if (file.create(tmp2)) cleanFile(tmp2, delay = 0)
}

Description

• permutation computes the number of permutations

• variation computes the number of variations with and without replication

• combination computes the number of combinations with and without replication

• combinatorics computes all combinatorics results for k < n and returns it as list of:

  permutation.n

  $P(n)$

  permutation.k

  $P(k)$

  permutation.nk

  $P(n; k)$

  variation

  $V(n;k)$

  variation.rep

  $V^W(n;k)$

  combination

  $K(n;k)$

  combination.rep

  $K^W(n;k)$

• lfact computes the natural logarithm of the factorial of a given number n

• lfactquot calculates the natural logarithm of the quotient of factorials

• lbinom computes the natural logarithm of the binomial coefficient, "n choose k"

Usage

combinatorics(n, k)

variation(n, k, repl = FALSE)

combination(n, k, repl = FALSE)

permutation(n, k = rep(1, n))

lfact(n)

lfactquot(n, ...)

lbinom(n, k)

combo(n, k, repl = FALSE)

combs(n, k)

fact(n)

factquot(n, ...)

binom(n, k)

Arguments

Value

A list.

Examples

permutation(8)
permutation(8, c(1,3,2,2))
combination(8, 4)
combination(8, 4, TRUE)
variation(8, 4)
variation(8, 4, TRUE)
combinatorics(8, 4)

Description

Rearranges the order of y to construct a dataset with a target correlation r between x and y, as defined by stats::cor(). The marginal distributions of x and y are preserved, but the achieved correlation may deviate from the target. The algorithm iteratively adjusts the ordering of y; increasing maxit may improve accuracy if results are unsatisfactory.

Usage

cor_data(
  x,
  y,
  r,
  method = c("pearson", "kendall", "spearman"),
  ...,
  maxit = 1000
)

dcorr(x, y, r, method = c("pearson", "kendall", "spearman"), ..., maxit = 1000)

Arguments

Value

A two-column matrix with x and reordered y. An attribute interim stores a matrix of intermediate values, which depends on method:

• pearson: Rows include $x_i$, $y_i$, $x_i - \bar{x}$, $y_i - \bar{y}$, squared deviations, and cross-products.

• kendall: Rows include $x_i$, $y_i$, $p_i$ (concordant pairs), and $q_i$ (discordant pairs).

• spearman: Rows include $x_i$, $y_i$, ranks of x and y, and squared rank differences.

In all cases, an additional column with row sums is appended.

Examples

x <- runif(6)
y <- runif(6)
xy <- cor_data(x, y, r = 0.6)
cbind(x, y, xy)

Description

Generate sequences of integers representing sample sizes within a specified range.

Functions support two specialized sequences:

• data_nsq / dnsq: sample sizes that are perfect squares.

• data_n25 / dn25: sample sizes divisible only by 2 and 5.

Usage

data_n(max, min = 5)

data_nsq(max, min = 5)

data_n25(max, min = 5)

dn(max, min = 5)

dn25(max, min = 5)

dnsq(max, min = 5)

Arguments

Value

An integer vector of sample sizes satisfying the criteria.

Examples

data_n(10)
data_nsq(1000)
data_n25(1000)

Description

Generates a nrow × ncol matrix with probabilities / frequencies. If data is given it will be normalized such that sum(data[is.finite(data)])==1. If no rownames or colnames are given then event names from LETTERS are used. The returned matrix will have the following attributes:

• marginals a list of the row and column marginal distributions

• byrow a matrix with conditional probabilities by row

• bycol a matrix with conditional probabilities by column

• expected a matrix with the expected probabilities under independence

• prob a vector of all the probabilities computed (except the expected ones)

Usage

data_prob2(
  data = NULL,
  nrow = 2,
  ncol = 2,
  colnames = NULL,
  rownames = NULL,
  ...
)

prob_mx(data = NULL, nrow = 2, ncol = 2, colnames = NULL, rownames = NULL, ...)

dprob2(data = NULL, nrow = 2, ncol = 2, colnames = NULL, rownames = NULL, ...)

Arguments

Value

A matrix and some attributes.

Examples

x <- data_prob2()
str(x)
data_prob2(colnames="E")
data_prob2(nrow=3)

Description

Creates a discrete probability function based on x with a resolution unit. If unit is not given then unit will be 10, 100, 1000, ... depending on the length of the discrete probability function.

Usage

ddiscrete(x, unit = NULL, zero = FALSE)

Arguments

Value

A discrete probability function.

Examples

ddiscrete(runif(6))
ddiscrete(6)
ddiscrete(6, 20)
ddiscrete(c(1,0,0,0), zero=TRUE)

Description

Creates a bivariate discrete probability function based on the marginal probability functions row and col. If unit is not given then unit will be the product of the units used in row and col, otherwise it will appear as the least common multiple unit product of the units used in row and col. If target is NA then the common distribution of two independent random variables is returned, otherwise an iterative algorithm is run to approach a target association or correlation measure, see also assoc_data() (called internally). zero allows for zero entries in the common distribution. FUN computes the association or correlation measures based on a frequency table. tol gives the maximal deviation of the association or correlation measure and the target value. maxit limits the number of steps. Please note that a solution is not guaranteed, especially for extreme values for target, for example for $+1$, $-1$ or nearby values. If attr(joint, "iterations")==maxit then you need either to increase maxit, to decrease tol or to check if you have chosen an appropriate target value (for a nominal measure in $0 <= target <= 1$, for ordinal measure in $-1 <= target <= +1$).

Usage

ddiscrete2(
  row,
  col,
  unit = NULL,
  zero = FALSE,
  FUN = nom.cc,
  target = NA,
  tol = 0.001,
  maxit = 500,
  ...
)

biv_discrete_prob(
  row,
  col,
  unit = NULL,
  zero = FALSE,
  FUN = nom.cc,
  target = NA,
  tol = 0.001,
  maxit = 500,
  ...
)

Arguments

Value

A bivariate discrete probability function.

Examples

row <- ddiscrete(runif(5))
col <- ddiscrete(runif(3))
joint <- ddiscrete2(row, col)
joint
joint <- ddiscrete2(row, col, target=0.5)
joint
nom.cc(joint*attr(joint, "unit"))

Description

Probability mass function, distribution function, quantile function and random generation for the sum of two independent discrete uniform distributions.

Usage

ddunif2(x, min = 1, max = 6)

pdunif2(q, min = 1, max = 6)

qdunif2(p, min = 1, max = 6)

rdunif2(n, min = 1, max = 6)

sum_discrete_unif_cdf(x, min = 1, max = 6)

sum_discrete_unif_pmf(q, min = 1, max = 6)

sum_discrete_unif_quantile(p, min = 1, max = 6)

sum_discrete_unif_rand(n, min = 1, max = 6)

Arguments

Value

A numeric vector with the same length as x.

Examples

ddunif2(1:13)
pdunif2(1:13)
qdunif2((0:4)/4)
rdunif2(10)

Description

Probability mass function, distribution function, quantile function and random generation for the discrete uniform distribution. Documentation, examples and interface are taken from extraDistr::DiscreteUniform.

Usage

ddunif(x, min, max, log = FALSE)

pdunif(q, min, max, lower.tail = TRUE, log.p = FALSE)

qdunif(p, min, max, lower.tail = TRUE, log.p = FALSE)

rdunif(n, min, max)

Arguments

Details

If min == max, then discrete uniform distribution is a degenerate distribution.

Examples

x <- rdunif(1e5, 1, 10) 
xx <- -1:11
plot(prop.table(table(x)), type = "h")
lines(xx, ddunif(xx, 1, 10), col = "red")
hist(pdunif(x, 1, 10))
xx <- seq(-1, 11, by = 0.01)
plot(ecdf(x))
lines(xx, pdunif(xx, 1, 10), col = "red")

Description

Holds an univariate distribution including its parameters. The name of the distribution is used to determine the right use of the function. For example, in the case of function for quantiles: paste0("q", name). Usually the full name has to be used; some abbreviated names are possible:

• binom binomial distribution, parameters: size, prob

• hyper hypergeometric distribution, parameters: m, n, k

• geom geometric distribution, parameters: prob

• pois Poisson distribution, parameters: lambda

• unif continuous uniform distribution, parameters: min, max

• dunif discrete uniform distribution, parameters: min, max

• dunif2 continuous uniform distribution, parameters: min, max

• exp exponential distribution, parameter: rate

• norm normal distribution, parameters: mean, sd

• lnorm log-normal distribution, parameters: meanlog, sdlog

• t Student t distribution, parameter: df

• chisq chi-squared distribution, parameter: df

• f F distribution, parameters: df1, df2

Note that a probability mass/density, quantile and a cumulative distribution function must exist.

The following functions exists for disributions:

• distribution creates a distribution with name and parameters

• quantile computes the quantiles of a distribution using paste0('q', name)

• cdf computes the cumulative distribution function of a distribution using paste0('p', name)

• pmdf computes the probability mass/density function of a distribution using paste0('d', name)

• prob computes the probability for a interval between min and max (max included, min excluded)

• prob1 computes the point probability f

• is.distribution checks if object is distribution object. If name is given then it checks whether the distribution type is the same

• toLatex generates a LaTeX representation of the distribution an its parameter

Usage

distribution(name, ...)

## Default S3 method:
distribution(name, ..., discrete = NA)

## S3 method for class 'distribution'
quantile(x, probs = seq(0, 1, 0.25), ...)

cdf(x, q, ...)

## S3 method for class 'distribution'
print(x, ...)

## S3 method for class 'distribution'
summary(object, ...)

pmdf(d, x, ...)

## S3 method for class 'distribution'
toLatex(object, name = NULL, param = NULL, digits = 4, ...)

is.distribution(object, name = NULL)

prob(d, min = -Inf, max = +Inf, tol = 1e-06)

prob1(d, x, tol = 1e-06)

compute_cdf(x, q, ...)

compute_pmdf(d, x, ...)

compute_probability(d, min = -Inf, max = +Inf, tol = 1e-06)

point_probability(d, x, tol = 1e-06)

pprob(d, x, tol = 1e-06)

is_distribution(object, name = NULL)

Arguments

Value

A distribution object.

Examples

d <- distribution("norm", mean=0, sd=1)
quantile(d)
quantile(d, c(0.025, 0.975))
cdf(d, 0)
is.distribution(d)
is.distribution(d, "t")
toLatex(d)

Description

A data frame with the R function names, LaTeX names, discreteness and package origin of a distribution.

Usage

data(distributions)

Format

A data frame with columns r, latex, discret and package

Examples

data(distributions)
distributions

Description

• is_terminal checks whether x's can be expressed as a terminal fraction, basically divisor_25(denominator(x))

• divisor_25 checks whether all x's can be expressed as $2^x 5^y$

• prime_numbers returns all prime numbers up to a limit

• primes prime factorization of x, returns a matrix with the power of each prime number

• has_digits checks whether the x's have only digits after the decimal point, basically abs(x-round(x, digits))<tol

• all_integer checks whether all x's are integer, basically all(has_digits(x,0))

Usage

divisor_25(x)

denominator_25(x)

is_terminal(x)

round_25(x)

prime_numbers(n, sieve = FALSE)

primes(x, min = 2)

has_digits(
  x,
  digits = 2,
  tol = 10^{
     -digits - 6
 }
)

all_integer(x)

only_digits(
  x,
  digits = 2,
  tol = 10^{
     -digits - 6
 }
)

is_term(x)

denom_25(x)

Arguments

Value

logical

Examples

is_terminal(2/3)   # 0.6666... non-terminal
is_terminal(1/5)   # 0.2       terminal
divisor_25(1:25)
prime_numbers(100) # all prime numbers less equal 100
primes(1:20)       # prime factorization of 1 to twenty

Description

It performs a comparison by checking if either abs(x - y) < tol when outer == FALSE, or if an a exists or a y[j] for each x[i] such that the condition abs(x[i] - y[j]) < tol is satisfied.

Usage

equal(x, y, tol = 1e-06, outer = FALSE)

approx_equal(x, y, tol = 1e-06, outer = FALSE)

Arguments

Value

logical

Examples

equal(9*1/9, 1)

Description

equations defines a set of equations using the formula interface including a LaTeX representation of the formulae.

variables sets the variable values, the LaTeX representation and the solution interval. The first argument must be the equations object. A named parameter starts the setting for a specific variable, e.g. ⁠..., s=1, pos(5), "s^2",...⁠ sets for the variable s first its numerical value, second the solution interval and finally the LaTeX representation.

Usage

equations(...)

variables(...)

Arguments

Value

(for equations) An equations object.

(for variables) The modified equations object.

Examples

# The equations describe the formulae for an confidence interval of the mean
e <- equations(o~x+c*s/sqrt(n), "v_o=\\bar{x}+c\\cdot\\frac{s^2}{n}", 
               u~x-c*s/sqrt(n), "v_u=\\bar{x}-c\\cdot\\frac{s^2}{n}", 
               e~c*s/sqrt(n),   "e  =c\\cdot\\frac{s^2}{\\sqrt{n}}",
               l~2*e,           "l  =2\\cdot e"                   
               )
print(e)
e <- variables(e, 
               x=0,    "\\bar{x}",
               c=2.58, dbl(2), 
               s=1,    pos(5), "s^2",
               n=25,   pos(5),
               l=pos(5), 
               e=pos(5),
               u="v_u", o="v_o")
print(e)

Description

Returns a list with the functions' names and parameters called from .traceback(). The function name must start with "exams2".

Usage

exams2call(prefix = "exams2")

Arguments

Value

A list with the function name and its evaluated parameters.

Examples

exams2call()                 # access current call stack

Description

Data structure for exercise data.

Usage

exercise(exer, ...)

## Default S3 method:
exercise(exer = NULL, ...)

exercise_data(exer, ...)

Arguments

Value

An exercise object.

Examples

exer <- exercise()           # new exercise
exer <- exercise(exer, x=3)  # add x to the exercise

Description

Computes the real valued extremes (minima, maxima, and saddle points) for a univariate polynomial. The computation can be limited to a specific type of extremes.

Usage

extremes(p, type = c("all", "minimum", "maximum", "saddle"), tol = 1e-09)

Arguments

Value

A numeric vector.

Examples

p <- polynomial(c(0,0,0,1))
extremes(p)
p <- integral(poly.calc(-1:1))
extremes(p)

Description

Converts a number to a string containing either a floating point or a fractional number. Note that a repeating or recurring decimal, which is a number whose decimal representation becomes periodic, can also be expressed as a rational number. For example, $\frac{1}{3}=0.333333333...=0.\overline{3}$. It is the workhorse used in num2str.

• If denom is negative then always decimal point numbers are used (default).

• If denom is zero then a mix of decimal point and fractional numbers are used (whatever is shorter).

• If denom is one then fractional numbers are used except for integers.

• If denom is larger than one, then the denominator is set to denom if possible.

Usage

fcvt(x, nsmall = 15, plus = FALSE, denom = -1)

Arguments

Value

A character.

Examples

x1 <- c(NA, NaN, -Inf, Inf, 0, pi*10^(-20:20))
fcvt(x1)
x2 <- c(-0.36, 3.6, -30.6, 0.36)
fcvt(x2)
x3 <- c((0:16)/8, 1/3)
fcvt(x3)           # as floating point number, equals denom=-1
fcvt(x3, denom=0)  # as floating point or fractional number
fcvt(x3, denom=1)  # as fractional number except for integers
fcvt(x3, denom=8)  # as fractional number with denominator denom if possible

Description

firstmatch seeks matches for the elements of its first argument among those of its second. For further details please check base::charmatch(). charmatch returns a zero if multiple matches are found, whereas firstmatch returns the first partial match if multiple matches are found.

Usage

firstmatch(x, table, nomatch = NA_integer_)

Arguments

Value

An integer.

Examples

firstmatch("d", c("chisq", "cauchy"))
charmatch("c", c("chisq", "cauchy"))
firstmatch("c", c("chisq", "cauchy"))
firstmatch("ca", c("chisq", "cauchy"))

Description

Finds rational approximations to the components of a real numeric object, using a standard continued fraction method. Calls MASS::fractions() (Please refer to that for further details).

Usage

fractions(x, cycles = 10, max.denominator = 2000, ...)

approx_rational(x, cycles = 10, max.denominator = 2000, ...)

Arguments

Value

An object of the class fractions. A structure with a .Data component, the same as the numeric x input, but with the rational approximations held as the character vector attribute fracs. Arithmetic operations on fractions objects are possible.

Examples

X <- matrix(runif(25), 5, 5)
fractions(X) #;)
fractions(solve(X, X/5))
fractions(solve(X, X/5)) + 1

Description

Runs all combinations of elements in ... as parameters of FUN (grid apply). I(.) can be used to avoid that an element is interpreted as a grid value. If an error occurs, then the result of FUN will not be stored. You may notice missing indices in the returning list.

Usage

gapply(FUN, ..., .simplify = TRUE)

apply_grid(FUN, ..., .simplify = TRUE)

Arguments

Value

A list or a data frame with the function results.

Examples

# 8 function calls: sum(1,3,5), sum(1,3,6), ..., sum(2,4,6)
gapply("sum", 1:2, 3:4, 5:6)
# 4 function calls: sum(1,3,5:6), sum(1,4,5:66), ..., sum(2,4,5:6)
gapply("sum", 1:2, 3:4, I(5:6))

Description

Returns the names of an object as a character vector. Optionally enforces that names are non-NULL and non-empty when strict = TRUE. The function does not modify the original object.

Usage

getNames(x, strict = FALSE)

Arguments

Value

A character vector of names, same length as x.

• If x is an empty list or zero-length object, returns character(0).

• If names(x) is NULL and strict = FALSE, returns a vector of empty strings of the same length as x.

Examples

x <- c(a = 1, b = 2)
getNames(x)

y <- 1:3
getNames(y)

z <- c(1, 2); names(z) <- c("a", "")
# getNames(z, strict = TRUE) # would throw an error: "`x` has empty name(s)"

# Empty list returns character(0)
getNames(list(), strict = TRUE)

# NULL input triggers an error
# getNames(NULL, strict = TRUE)

Description

Computes a grade based on the points of the grade scheme by the Humboldt University of Berlin. (See §96c and §102 in the Achte Änderung der Fächerübergreifenden Satzung zur Regelung von Zulassung, Studium und Prüfung der Humboldt-Universität zu Berlin (ZSP-HU))

Usage

grade(points, maxpts = max(points), fixed = TRUE)

hu_grade(points, maxpts = max(points), fixed = TRUE)

Arguments

Value

Grades as a function of points.

Examples

x <- round(runif(100, 0, 22.4))
grade(x, 22)

Description

Computes mean, mode or quantile/median of grouped data.

Usage

grouped_data(x, n, compute = c("mean", "fine", "coarse"), tol = 1e-06)

grouped_stats(x, n, compute = c("mean", "fine", "coarse"), tol = 1e-06)

dgrouped(x, n, compute = c("mean", "fine", "coarse"), tol = 1e-06)

Arguments

Value

A list with the class, result and a table.

Examples

x <- 1:4
n <- ddiscrete(runif(3))
grouped_data(x, n)

Description

Simplifies a hyperloop object if possible.

Usage

gsimplify(ga, exclude = NULL, subset = NULL)

simplify_hyperloop(ga, exclude = NULL, subset = NULL)

simple_hloop(ga, exclude = NULL, subset = NULL)

Arguments

Value

A data frame if possible, otherwise a list.

Examples

# calls: t.test(x, -1), t.test(x, 0), t.test(x, 1)
ga <- gapply(t.test, x=I(rnorm(100)), mu=-1:1)
# no simplication since `data.name` and `conf.int` have lengths larger  than one
gsimplify(ga)
#' simplification is now possible
gsimplify(ga, exclude=c("conf.int", "data.name"))

Description

Randomly selects size breakpoints from breaks. If outer is TRUE, then the first and last element of breaks is always included into the returned break points. If size is a vector, the number of breakpoints is first sampled from size.

Usage

histbreaks(breaks, size, outer = TRUE, ...)

rand_breaks(breaks, size, outer = TRUE, ...)

dhistbreaks(breaks, size, outer = TRUE, ...)

Arguments

Value

A vector of breakpoints.

Examples

# Always includes 100 and 200
histbreaks(seq(100, 200, by=10), 4)
# Always includes 100 and 200 and chooses randomly between 3 to 5 break points  
histbreaks(seq(100, 200, by=10), 3:5)           
# May not include 100 and 200
histbreaks(seq(100, 200, by=10), 4, outer=FALSE)

Description

Returns data for a histogram. Calls internally hist(..., plot=FALSE).

• mean returns the mean of the data.

• quantile and median return the quantile(s) or median with an attribute pos, the class number of the quantile(s), or the median.

Usage

histdata(x, breaks = "Sturges", probs = seq(0, 1, 0.25), ...)

## S3 method for class 'histogram'
quantile(x, probs = seq(0, 1, 0.25), ...)

## S3 method for class 'histogram'
median(x, ...)

## S3 method for class 'histogram'
mean(x, ...)

dhist(x, breaks = "Sturges", probs = seq(0, 1, 0.25), ...)

Arguments

Value

Like in graphics::hist, but with this additional list of elements:

• lower lower class borders,

• upper upper class borders,

• width class widths,

• relfreq the relative class frequency,

• cumfbrk the cumulated relative frequency of the breaks,

• maxdens the indices of the maximal density values,

• maxcount the indices of the maximal count values

• x the original finite data, and

• class the class number for each value in x.

Examples

#1
x <- seq(0, 1, by=0.25)
print(hist(x, plot=FALSE))
histdata(x)
#2
x <- seq(0, 1, by=0.25)
print(hist(x, x, plot=FALSE))
histdata(x, x)
#3
print(hist(x, x, right=FALSE, plot=FALSE))
histdata(x, x, right=FALSE)

Description

Generates a set of class breaks and absolute frequencies for the range from from to to. Class widths are randomly sampled from the vector widths. The total number of classes (nb) must be an integer multiple of min(widths); otherwise, the function stops with an error. If the initial frequencies (n) are too small, they can be scaled by an integer factor. The routine also checks whether the resulting class densities are terminating decimals.

Usage

histwidth(from, to, widths, dmax = 2000, maxit = 1000)

width_breaks(from, to, widths, dmax = 2000, maxit = 1000)

dhistwidth(from, to, widths, dmax = 2000, maxit = 1000)

Arguments

Value

A list containing:

Examples

l <- histwidth(1.6, 2.1, widths = c(0.05, 0.1, 0.15, 0.2))
x <- histx(l$breaks, l$n)
histdata(x, l$breaks)
# Fallback: use constant min(widths) if no valid break pattern 
# is found within max iterations
l <- histwidth(1.6, 2.1, widths=0.05, dmax=10)
str(l)

Description

Given the breaks and the number of observations, a data set is generated with stats::runif(), using the class mids: $x_i = class\_mid_j + alpha*class\_width_j/2$. The default alpha=0.99 ensures that generated observations do not lie on the class borders.

Usage

histx(breaks, n, alpha = 0.99)

gen_mid(breaks, n, alpha = 0.99)

dhistx(breaks, n, alpha = 0.99)

Arguments

Value

The generated data set.

Examples

breaks <- sort(sample(seq(0.1, 0.9, by=0.1), 4))
bins   <- length(breaks)-1
n      <- rmultinom(1, size=100, prob=ddiscrete(runif(bins)))
histx(breaks, n)

Description

• hm_cell or hm_index modify a data cell format (fmt="%s"), value (unnamed parameter) or style (text_align="left")

• hm_col or hm_row modify a row or column format (fmt="%s"), value (unnamed parameter) or style (text_align="left")

• hm_title modifies the title attribute of an html_matrix based on specific arguments

• hm_table modifies the properties of the entire HTML table within an html_matrix

• hm_tr modifies the properties of one or more table rows (tr elements) in an html_matrix. Row indices for modification (ind) can be specified along with additional parameters to customize the row format, values, or style

Usage

hm_cell(x, row = NULL, col = NULL, ..., byrow = FALSE)

hm_index(x, ind, ...)

hm_title(x, ...)

hm_table(x, ...)

hm_row(x, ind, ...)

hm_col(x, ind, ...)

hm_tr(x, ind, ...)

modify_cell(x, row = NULL, col = NULL, ..., byrow = FALSE)

mod_cell(x, row = NULL, col = NULL, ..., byrow = FALSE)

modify_col(x, ind, ...)

mod_col(x, ind, ...)

modify_index(x, ind, ...)

mod_ind(x, ind, ...)

modify_row(x, ind, ...)

mod_row(x, ind, ...)

modify_table(x, ...)

mod_t(x, ...)

modify_title(x, ...)

mod_title(x, ...)

modify_tr(x, ind, ...)

mod_tr(x, ind, ...)

Arguments

Value

A modified html_matrix object.

Examples

l <- html_matrix(matrix(1:6, ncol=2))
# replace l[1,1] by NA
hm_cell(l, 1, 1, NA)
# replace l[1,1] by NA and set the text_align to center
hm_cell(l, 1, 1, NA, text_align="center")
# replace l[1,3] and l[2,1] by NA
rcind <- cbind(c(1,3), c(2, 1))
hm_index(l, rcind, NA)
# set a new title
hm_title(l, "new title")
# set a new row or column title
hm_row(l, 2, "row 2")
hm_col(l, 1, "col 1")
# set fmt by column or row
print(hm_cell(l, fmt=c("%.0f", "%.1f", "%.2f"), byrow=FALSE), which="fmt")
print(hm_cell(l, fmt=c("%.0f", "%.1f"), byrow=TRUE), which="fmt")

Description

Creates an HTML page with all the contents of the XML tags whose names match pattern.

The default is to show the contents of all XML tags. The HTML page is stored in the HTML file name.

The default name=NULL creates a temporary file. If the name does not end in .html, then a .html is appended.

If browseURL=TRUE (default) then the HTML page will be displayed in the browser.

If necessary the contents of XML tags are concatenated with "\n". For single XML tags this can be changed, e.g. merge=list("questionlist"="<br>" leads to the XML tag <questionlist>...</questionlist>) "<br>" being used ,instead of the "\n".

Usage

html_e2m(
  exam,
  name = NULL,
  pattern = ".",
  mathjax = TRUE,
  browseURL = TRUE,
  overwrite = FALSE,
  header = 2,
  merge = list(questionlist = "<br>"),
  png = TRUE
)

toHTML_XML(
  exam,
  name = NULL,
  pattern = ".",
  mathjax = TRUE,
  browseURL = TRUE,
  overwrite = FALSE,
  header = 2,
  merge = list(questionlist = "<br>"),
  png = TRUE
)

Arguments

Value

Invisibly, the names of listed elements in the HTML file.

See Also

The aim is similar to exams:::exams:::browse_exercise, however, html_e2m takes the information form the XML file generated by the exams.forge package.

Examples

if (interactive()) {
  resexams <- readRDS(system.file("xml", "klausur-test.rds", package="exams.moodle"))
  html_e2m(resexams) # opens HTML file into browser
}

Description

Creates from a vector, a matrix, an array, or a table, an HTML representation of it. The HTML representation has one column and one row more than the data. The additional row and column are used in order to have a title (top left), the column names (top), and the row names (left).

You can set the style attributes (⁠<td style="...">⁠) via hm_cell, hm_title, hm_col, and hm_row. For example: hm_cell(hm, 1, 1, text_align="right") will lead to (⁠<td style="text-align:right;">⁠) for the cell (1,1), and any unnamed element will change the cell value. Note: since - is an operator in R, we use ⁠_⁠ instead. Of course, someone could use "text-align"="right", but I am lazy.

Usage

html_matrix(x, ...)

## Default S3 method:
html_matrix(
  x,
  ...,
  byrow = FALSE,
  numeric = list(text_align = "right"),
  integer = list(text_align = "right"),
  char = list(text_align = "left"),
  logical = list(text_align = "right"),
  border = "#999999"
)

html_mx(x, ...)

Arguments

Value

Returns an html_matrix.

Examples

m <- matrix(1:6, ncol=2)
m
l <- html_matrix(m)
l

Description

My personal pipe creating an html_matrix object. Note that the length of fmt must be either nrow(m) or ncol(m) depending on byrow.

   html_matrix(m) 
     tooltip(sprintf(tooltip, nrow(m), ncol(m))) 
     hm_cell(fmt=fmt, byrow=byrow)

Usage

html_matrix_sk(
  m,
  title,
  fmt,
  byrow = TRUE,
  tooltip = "Die Tabelle hat %.0f Zeilen und %.0f Spalten",
  ...
)

lmatrix(
  m,
  title,
  fmt,
  byrow = TRUE,
  tooltip = "Die Tabelle hat %.0f Zeilen und %.0f Spalten",
  ...
)

Arguments

Value

An html_matrix object.

Examples

m <- matrix(1:6, ncol=2)
html_matrix_sk(m, title="", fmt=c("%.0f", "%.1f"))

Description

Generates a data frame with potential values for m, n and k. If hyper2 is FALSE then the parametrization of stats::dhyper() is used, otherwise n+m, m and k is used and transformed to m, n and k. In accordance with specific conditions it holds that:

• if length(mean)==1 and it's an integer, it signifies the desired number of digits for the mean

• if mean is set to NA (the default), all means are permissible

• when length(mean) > 1, the product $k*m/(n+m)$ must be one of the valid means

• the same rules apply to sd

The parameters norm, pois and binom can take on the values NA, TRUE, FALSE, or be defined as a function of the format: ⁠function(m, n, k)⁠. These values determine which ⁠(m, n, k)⁠ combinations are eligible:

• for NA, all combinations of ⁠(m, n, k)⁠ are acceptable

• if specified as a function, only those combinations for which the function evaluates to TRUE are considered valid

• if set to TRUE, combinations are accepted only if they satisfy either the condition $k*m/(m+n)*(1-m/(m+n))>=9$ (for norm, indicating a normal distribution approximation), the conditions $k/(n+m) < 0.05$, $m/(n+m) < 0.05$ and $k>10$ (for pois, implying a Poisson distribution approximation) and the condition $k/(n+m) < 0.05$ (for binom, implying a binomial distribution approximation)

• if set to FALSE, the approximations should not hold for any combination.

Please be aware that there is no guarantee that the resulting data frame will include a valid solution.

Usage

hyper_param(
  m,
  n,
  k,
  mean = NA,
  sd = NA,
  norm = NA,
  pois = NA,
  binom = NA,
  tol = 1e-06,
  hyper2 = FALSE
)

Arguments

Value

A data frame with possible the choices of n , p, mean and sd.

Examples

hyper_param(7:14, 1:13, 3:10, norm=FALSE, pois=FALSE, binom=FALSE, hyper2=TRUE)

Description

Runs a function several times with all parameter combinations, and checks:

• if an argument is not a list, then it will be converted to an one element list

• if an error occurs then the result of FUN will not be stored

Usage

hyperloop(FUN, ..., .simplify = FALSE)

hloop(FUN, ..., .simplify = FALSE)

Arguments

Value

A hyperloop object as a list.

Examples

x   <- rnorm(100)
trm <- hyperloop(mean, x=list(x), trim=as.list(seq(0, 0.5, by=0.05)))
# automatic conversion of x to list(x)
trm <- hyperloop(mean, x=x, trim=as.list(seq(0, 0.5, by=0.05))) 
unlist(trm)

Description

Creates a data frame for a test hypothesis with various columns:

• h0.left left value of the null hypothesis, usually ⁠\mu⁠ or ⁠\pi⁠

• h0.operator operator of the null hypothesis, one of the following: eq, ne, lt, le, gt, or ge

• h0.right right value of the null hypothesis, usually ⁠\mu_0⁠, ⁠\pi_0⁠, or a hypothetical value

• h1.left left value of the alternative hypothesis, usually ⁠\mu⁠ or ⁠\pi⁠

• h1.operator operator of the alternative hypothesis, one of the following: eq, ne, lt, le, gt, or ge

• h1.right right value of the alternative hypothesis, usually ⁠\mu_0⁠, ⁠\pi_0⁠, or a hypothetical value

• H0 latex representation of the null hypothesis

• H1 latex representation of the alternative hypothesis

• match.left do the left value in the null and the alternative hypothesis match?

• match.right do the right value in the null and the alternative hypothesis match?

• match.operator do the operators in the null and the alternative hypothesis cover all real numbers?

• match.right do the right value in the null and alternative hypothesis match?

• match.type either wrong, left.sided, right.sided, two.sided, greater, or less.