exams.forge: A brief description the package

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 sigbert@wiwi.hu-berlin.de

License

Gnu General Public License 3.

Author(s)

Maintainer: Sigbert Klinke sigbert@hu-berlin.de

Confidence Intervals

Description

The CImu_data function is designed for the generation of confidence intervals pertaining to a population mean mu. The function accommodates scenarios in which a dataset x is either provided or generated through a random sampling process from a normal distribution, with user-specified parameters such as a mean mu and a standard deviation sigma. Subsequently, the function computes essential statistical measures, including the sample mean xbar and the standard deviation sd. Confidence intervals for the population mean are then calculated at user-defined confidence levels (conf.level). The output is a structured list containing pertinent statistics, encompassing the mean, sample standard deviation, confidence intervals, and other relevant details.

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 with

• a with 1-(1-conf.level)/2

• n number observations if given

• xbar mean of observations if not given

• mu theoretical mean if given

• sd standard deviation of observations

• sigma theoretical standard deviation if given

• df degrees of freedom if a t distribution is used

• q if sigma=NULL

• ss either sd or sigma

• e margin of error (half of the length of the confidence interval(s))

• l length of the confidence interval(s)

• v endpoints of the confidence interval(s)

Examples

# with data
x <- rnorm(100)
CImu_data(x, conf.level=0.95)
# simulate data internally
CImu_data(n=100, conf.level=0.95, mu=0, sigma=1)

Confidence Interval and Sample Size for the Population Mean Value

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)

Confidence Interval and Sample Size for the Population Proportion

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)

Vector Data Addition

Description

Adds data values to a given data vector x.

Usage

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

Arguments

Details

Based on the data x, or the range(box), a box is computed. The length of the box gives the multiplier for the range. Then a left and right interval, from which the additional values are drawn uniformly, is computed: [left box value-range[2]*box length; left box value-range[1]*box length] (left interval) and [right box value+range[1]*box length; right box value+range[2]*box length] (right interval).

For box, "boxplot" can be also used and quantile(x, c(0.25, 0.75), na.rm=TRUE) can be used instead of range(x, na.rm=TRUE).

n can be a single number which will add n data values at the right side of x. If n is a vector of length two, then n[1] data values will be added at the left side of x and n[2] data values will be added at the right side of x.

Value

a data vector with new values

Examples

x <- rnorm(8)
# add one value to the right
add_data(x, "box", range=1.5)
add_data(x, "range", range=0.1)
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)

Quote and Prefix and/or Suffix Manipulation

Description

affix adds a prefix and/or a suffix to a (character) vector

math adds a $ as pre- and suffix to a (character) vector

bracket adds a ( as prefix and ) as suffix to a (character) vector

unaffix deletes a pre- and/or suffix to a (character) vector

unquote deletes double quotes at the beginning and the ending of a (character) vector

uncdata deletes a <![CDATA[ as prefix and ]]> as suffix

cdata adds a <![CDATA[ as prefix and ]]> as suffix

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 character vector

Examples

x <- runif(5)
affix(x, "$", "$")
math(x)

Difference Testing

Description

Tests if the differences between the entries in obj are larger than tol.

Usage

all_different(obj, tol)

Arguments

Value

logical

Examples

x <- runif(10)
all_different(x, 0.0001)
all_different(x, 1)

Results with Rounding

Description

Rounds x according to digits, FUN and sets a tolerance for the result. If the tolerance is not stated, consider it the maximum of 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

Value

A list with the original and a rounded value, digits used and tolerance.

Examples

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

Vector to String Conversion

Description

Converts a character vector into a single string.

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 string

Examples

x <- runif(5)
y <- c(TRUE, FALSE, NA) 
as_string(x)
as_string(y)
# toString
as_string(as.character(x))
as_string(as.character(y))
#
as_obs(x)
as_obs(sort(x), sorted=TRUE)
#
x <- round(runif(5), 2)
as_fraction(x)
as_fraction(x, TRUE)
#
y <- round(runif(5), 2)
as_sum(x)

Conversion to Table

Description

Converts a vector into a horizontal table.

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

Value

A string.

Examples

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

Time Series

Description

Converts a ts_data object into a time series object (ts).

Usage

as_ts(ts)

Arguments

Value

A ts object.

Examples

# Time series from linear trend
ts <- ts_data(12, trend.coeff= c(sample(0:10, 1), sample(1+(1:10)/20, 1)))
as_ts(ts)

Frequency Optimization

Description

Given a frequency table, the function reorders the observations such that the given target association will be approximated and the marginal frequencies remain unchanged. Note that the target association may not be reached! zero allows for zero entries in the common distribution. If target is NA then the table is simply returned. FUN computes the association (or correlation) measure 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 of 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 check if you have chosen an appropriate target value (for a nominal measure in 0 <= target <= 1, for ordinal measure in -1 <= target <= +1). attr(joint, "target") contains the achieved association.

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

Value

a modified frequency table

Examples

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

Binomial Parameters

Description

Generates a data frame with potential values for size and prob, and is subjected to specific conditions:

• 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 size * prob must be one of the valid means.

• The same rules applies to sd.

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

• For NA, all combinations of ⁠(size, prob)⁠ are acceptable.

• If specified as a function, only those combinations for which the function returns TRUE are considered valid.

• If set to TRUE, combinations are accepted only if they satisfy either the condition size * prob * (1 - prob) > 9 (for norm, indicating a normal distribution approximation), or the conditions prob < 0.05 and n > 10 (for pois, implying a Poisson 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

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

Arguments

Value

a data frame with possible choices of n , p, mean and sd

Examples

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

Breaks

Description

Creates a number of equidistant or non-equidistant breaks for given data x. If width is not given then it will be set to diff(pretty(x))[1]. probs can either be a single integer, giving the number of quantiles, or a vector of probabilities with values in [0,1]. Please note that if width is too large, then using probs may result in equidistant breaks too.

Usage

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

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

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

Arguments

Value

A numeric vector of breaks.

Examples

x <- rnorm(100, mean=1.8, sd=0.1)
breaks(x)
breaks(x, 0.1)
breaks(x, 0.1, probs=4)

Function Calling

Description

Checks if the result from base::sys.calls contains a call from fun.

Usage

calledBy(fun = "exams2pdf")

called_by(fun = "exams2pdf")

Arguments

Value

logical

Examples

funb <- function() { calledBy('funa') }
funa <- function() { funb() }
funa()

Condition cat

Description

Calls cat if cond==TRUE.

Usage

catif(cond, ...)

condition_cat(cond, ...)

Arguments

Value

Invisibly cond.

Examples

catif(TRUE, "PDF")      # Should appear
catif(FALSE, "Moodle")  # Should not appear

Combinatorics

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)

Correlation and Data Generation

Description

Generates a data set based on x and y for a given target correlation r according to stats::cor(). The algorithm modifies the order of the y's, therefore is guaranteed that the (marginal) distribution of x and y will not be modified. Please note that it is not guaranteed that the final correlation will be the desired correlation; the algorithm interactively modifies the order. If you are unsatisfied with the result, it might help to increase maxit.

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 matrix with two columns and an attribute interim for intermediate values as matrix. The rows of the matrix contain:

• if method=="pearson": x_i, y_i, x_i-bar{x}, y_i-\bar{y}, (x_i-bar{x})^2, (y_i-\bar{y})^2, and (x_i-bar{x})((y_i-\bar{y}).

• if method=="kendall":

  • x_i: The original x values.

  • y_i: The original y values.

  • p_i: The number of concordant pairs.

  • q_i: The number of discordant pairs.

• if method=="spearman": x_i, y_i, p_i (concordant pairs), and q_i (disconcordant pairs). In a final step a vector with the row sums is appended as further column.

Examples

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

Number of Observations

Description

Generates a sequence of sample sizes in a range from min=5 to a max:

• whose root is an integer (data_nsq), and

• that are divisible only by 2 and 5 (data_n25)

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

A sequence of integers.

Examples

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

Probability/Frequency Matrix Generation

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)

Discrete Probability Function

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)

Bivariate Discrete Probability Function

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"))

Sum of Two Independent Discrete Uniform Distributions

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)

Class Distribution

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)

Distributions

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

Number Properties

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

Conditional Value Matching

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)

Equations and Variables

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)

Traceback for exams2 Functions

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 valuated parameters.

Examples

exams2call()                 # access current call stack

Data Exercise Structure

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

Extremes

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)

Number to String Conversion (Floating Point / Fractional Number)

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

Firstmatch

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"))

Fractions

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

Apply Grid

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))

Grades

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)

Central Tendency Measures' Computation of Grouped Data

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)

Simplified hyperloop Object

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"))

Histogram Breakpoints

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) 

Histogram Data

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)

Histogram Widths

Description

Creates a set of breaks and absolute frequencies in the range from 'from' to 'to'. The class widths are sampled from widths. The resulting numbers could be multiplied with an integer, if the sum(n) is too small. Additionally, it is checked whether the generated densities are terminating decimals.

Usage

histwidth(from, to, widths, dmax = 100)

width_breaks(from, to, widths, dmax = 100)

dhistwidth(from, to, widths, dmax = 100)

Arguments

Value

A list with breaks, n's for each class and decimal if all densities are terminating decimals.

Examples

l <- histwidth(1.6, 2.1, widths=c(0.05, 0.1, 0.15, 0.2))
l
x <- histx(l$breaks, l$n)
histdata(x, l$breaks)

Midpoint-Based Data Creation for a Histogram

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

q  <- sort(sample(seq(0.1, 0.9, by=0.1), 4))
qx <- pnorm(q)
histx(qx, diff(q))

html_mmatrix Modification

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")

HTML exams.forge

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
}

HTML Representation

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

html_matrix Object Creation

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"))

Parameters for Hypergeometric Distributions

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)

Hyperloop

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)

Latex Hypothesis

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.

If null is not given then it is determined from alternative. Otherwise hypotheses pairs are generated by all combinations from alternative and null. Valid values for alternativeand null are two.sided, greater, less, eq, ne, lt, le, gt, or ge.

Usage

hypothesis_latex(
  left,
  alternative = NULL,
  null = NULL,
  right = paste0(left, "_0")
)

lhypo(left, alternative = NULL, null = NULL, right = paste0(left, "_0"))

Arguments

Value

A data frame with hypothesis pairs.

Examples

# Create one hypotheses pair
hypothesis_latex("\\mu")
hypothesis_latex("\\pi")
hypothesis_latex("\\mu", alternative="two.sided")
hypothesis_latex("\\mu", alternative="two.sided", null="lt")
hypothesis_latex("\\mu", alternative="ne", null="eq")
hypothesis_latex("\\mu", right=c(0,1))
hypothesis_latex("\\mu", alternative=c("eq", "ne", "lt", "le", "gt", "ge"))
hypothesis_latex("\\mu", alternative=c("eq", "ne", "lt", "le", "gt", "ge"), 
                         null=c("eq", "ne", "lt", "le", "gt", "ge"))

Relative Contingency Table Fill

Description

Fills a relative contingency table with n missing values, such that the table entries can be recomputed. In case that no solution can be found, an error is generated.

Usage

incomplete_table(tab, n, maxit = 1000)

cont_table_fill(tab, n, maxit = 1000)

Arguments

Value

A contingency table including marginal values and total sum with missing values. The attribute fillin gives the necessary information about the order in which the entries can be calculated, while the attribute full presents the contingency table, including marginal values and total sum.

Examples

tab <- rbind(c(0.02, 0.04, 0.34), c(0.02, 0.28, 0.3))
incomplete_table(tab, 7)

Text Knitting

Description

Knits txt within an R code chunk.

Usage

inline(txt)

txt_knit(txt)

Arguments

Value

Output.

Examples

result <- inline("2 + 2")

Interval Checker

Description

Checks if x is in an opened or closed interval between min and max. The default is set as such, that the chosen interval is an interval of (0,1). For example, in the case of x being a probability.

Usage

is.prob(x, open = TRUE, min = 0, max = 1)

is_prob_interval(x, open = TRUE, min = 0, max = 1)

is_prob(x, open = TRUE, min = 0, max = 1)

in_range(x, open = TRUE, min = 0, max = 1)

Arguments

Value

A logical vector with the same length as x.

Examples

is.prob(runif(1))

Knitting a Text Argument

Description

Selects a text argument and returns the knitted result.

Usage

knitif(n, ..., envir = knit_global())

knit_select(n, ..., envir = knit_global())

Arguments

Value

A character.

Examples

knitif(runif(1)<0.5, 'TRUE'="`r pi`", 'FALSE'="$\\pi=`r pi`$")

Exam PDF with LaTeX

Description

If exams is called by exams2pdf,

• latexdef adds a TeX macro by ⁠\def\name{body}⁠ and

• answercol adds a ⁠\def\answercol{n}⁠ to modify the number of output columns for multiple-choice answers to the LaTeX file.

Usage

latexdef(name, body)

answercol(n)

add_answercol_def(n)

Arguments

Value

Nothing

Examples

answercol(2)

Least Common Multiple

Description

Computes the least common multiple for a numeric vector x.

Usage

lcmval(x)

lcm_vector(x)

Arguments

Value

The least common multiple.

Examples

lcmval(c(144, 160))      # = 1440
lcmval(c(144, 160, 175)) # = 50.400

Simple Linear Regression and Data Generation

Description

Creates data suitable for a simple linear regression. In the first step, data is computed using pearson_data(), satisfying the conditions \sum_{i=1}^{nmax} x_i^2 = n and \sum_{i=1}^{nmax} x_i = 0 (similar conditions apply to y. The data are then rescaled with x' = center[1]+scale[1]*x and y' = center[2]+scale[2]*y. Finally, a simple linear regression is performed on the transformed data.

Usage

lm1_data(
  r,
  n = 100,
  nmax = 6,
  maxt = 30,
  xsos = NULL,
  ysos = NULL,
  center = numeric(0),
  scale = numeric(0),
  ...
)

slr_data(
  r,
  n = 100,
  nmax = 6,
  maxt = 30,
  xsos = NULL,
  ysos = NULL,
  center = numeric(0),
  scale = numeric(0),
  ...
)

Arguments

Value

Returns an extended lm object and the additional list elements:

• inter contains intermediate results (the last column contains the row sums), and

• xy the generated x- and y-values.

Examples

data(sos)
n   <- sample(5:10, 1)
lm1 <- lm1_data(0.6, nmax=n, xsos=sos100)
str(lm1)

lm Simple Linear Regression

Description

Computes an lm object for a simple linear regression from a range of x and y values, including intermediate values. If r is not given then zero correlation is used (with cor_data). digits determines the rounding for the x and y values. If only one value is given, then it will be used for x and y. If no value is given then it will be determined from the x and y values by 3+ceiling(-log10(diff(range(.)))).

Usage

lmr_data(xr, yr, n, r = 0, digits = NULL, ...)

lm_regression_data(xr, yr, n, r = 0, digits = NULL, ...)

Arguments

Value

An object of the class lm with the additional components:

• x the generated x values

• y the generated y values

• sumx \sum_{i=1}^n x_i

• sumy \sum_{i=1}^n y_i

• sumx2 \sum_{i=1}^n x_i^2

• sumy2 \sum_{i=1}^n y_i^2

• sumxy \sum_{i=1}^n x_i y_i

• meanx the mean of x: 1/n \sum_{i=1}^n x_i

• meany the mean of y: 1/n \sum_{i=1}^n y_i

• varx the variation of x: \sum_{i=1}^n (x_i-\bar{x})^2

• vary the variation of y: \sum_{i=1}^n (y_i-\bar{y})^2

• varxy the common variation of x and y:\sum_{i=1}^n (x_i-\bar{x})(y_i-\bar{y})

• sxy the covariance of x and y

• rxy the correlation of x and y

• b0 the intercept of the linear regression

• b1 the slope of the linear regression

• r2 the coefficient of determination of the linear regression

Examples

# Engine displacement typically ranges from 500 to 2000 cm^3
# Fuel economy typically ranges from 2 to 8 liter/100 km
lmr <- lmr_data(c(500, 2000), c(2, 8), n=8)
str(lmr)

Supporting Functions for Math LaTeX Output

Description

lsumprod creates a latex printout of \sum_i x_i y_i with brackets if x_i or y_i starts with a -.

lsum creates a latex printout of x as sum.

lprod creates a latex printout of x as product.

lvec creates a latex printout of x as vector.

lmean creates a latex printout as \frac{x_1+...+x_n}{n}.

lvar creates a latex printout as \frac{(x_1-xbar)^2+...+(x_n-xbar)^2}{n}.

lbr creates a latex printout of x with brackets if x starts with a -.

lsgn creates a latex printout of x with a plus or minus at the beginning.

Usage

lsumprod(..., br = "(")

lsum(x)

lprod(x)

lvec(
  x,
  left = c("(", "[", "{", "|", "||", "<", "a", "c", "f"),
  right = NULL,
  collapse = ", "
)

lmean(x)

lvar(x, mu = NULL, br = "(")

lbr(x, br = c("(", "[", "{", "|", "||", "<", "a", "c", "f"), subset = NULL)

lsgn(x)

latex_sumprod(..., br = "(")

latex_sum(x)

latex_product(x)

latex_mean(x)

latex_var(x, mu = NULL, br = "(")

latex_bracket(
  x,
  br = c("(", "[", "{", "|", "||", "<", "a", "c", "f"),
  subset = NULL
)

latex_pmsign(x)

Arguments

Value

A character.

Examples

lsumprod(-2:2, (1:5)/10)
lbr(-2:2)
lsum(-2:2)
lmean(-2:2)
lvec(-2:2)
lvec(-2:2, '[')
lvec(0:1, '(', ']')

Character Key Generation

Description

Generates a character key from a vector of integers.

Usage

makekey(index)

make_key(index)

Arguments

Value

A character.

Examples

makekey(1)
makekey(1:2)
makekey(pi) # ;)
makekey(c(5,4))

Most Common Value

Description

Computes all modes (most common value).

Usage

mcval(x, ...)

## Default S3 method:
mcval(x, ...)

## S3 method for class 'histogram'
mcval(x, exact = FALSE, ...)

compute_modes(x, ...)

mcv(x, ...)

Arguments

Value

A vector of modes.

Examples

x <- sample(1:5, 15, replace=TRUE)
mcval(x)

Integer Observations and Mean

Description

The meanint_data function generates a set of integer observations with a specified integer mean. It takes the number of observations or x values and an optional range parameter, r, that defines the permissible range of x values (defaulting to the range of x). Additional parameters are passed to the mean function. The function employs a iterative process, adjusting individual observations to achieve an integer mean. It uses a random selection approach, modifying a randomly chosen observation and checking if the resulting mean is closer to an integer. The process continues until the mean becomes an integer.

Usage

meanint_data(x, r = range(x), ...)

Arguments

Value

A set of integer observations with an integer mean.

Examples

x <- meanint_data(10, c(1, 10))
mean(x)

Means

Description

Computes the means of x. The list returned has an attribute "mindiff" which contains the smallest distance between two mean values before rounding. If winsor and/or trim is set to NA then the trimmed and/or winsorized means are not computed. Currently implemented are:

mean

arithmetic mean

median

median

harmonic

harmonic mean

geometric

geometric mean

mode

(first) mode

trim

trimmed mean

winsor

winsorized mean

Usage

means_choice(x, digits, na.rm = TRUE, trim = 0.2, winsor = 0.2)

means(x, digits, na.rm = TRUE, trim = 0.2, winsor = 0.2)

Arguments

Value

A list with mean values.

Examples

x <- c(runif(9), 3)
means_choice(x, 2)

MIME Image

Description

Returns the MIME type of an image based on the filename extension. If a MIME type for a file extension cannot not found, then the extension itself will be returned.

Usage

mime_image(filename)

mime_img(filename)

Arguments

Value

A character.

Examples

mime_image("support.png")
mime_image("support.jpg")

Monomial

Description

Creates a polynomial of the form c*x^d.

Usage

monomial(degree = 1, coefficient = 1)

monom(degree = 1, coefficient = 1)

Arguments

Value

A polynomial

Examples

monomial()     # equivalent to polynomial()
monomial(3)    # x^3
monomial(3, 2) # 2*x^3

Moodle Multiple-Choice

Description

The exams package does not support multiple-choice questions with multiple correct answers; it only allows for one answer to be chosen. However, Moodle does support such questions. The function reads the XML file generated by exams.forge and makes changes for all mchoice questions:

• <single>...</single> to <single>true</single>, and

• modifies the attribute fraction in the tags <answer fraction="...">...</answer>. If fraction is less than 0, it is set to zero, and if fraction is greater than 0, it is set to 100.

If the file does not end with .xml, then .xml is appended. At the end, the modified XML code is stored in newfile.

Usage

moodle_m2s(file, newfile = NULL, verbose = 1)

mchoice_moodle(file, newfile = NULL, verbose = 1)

Arguments

Value

Invisibly, the written file name.

Examples

if (interactive()) {
  newfile <- tempfile(fileext=".xml")
  moodle_m2s(system.file("xml", "klausur-test.xml", package="exams.moodle"), newfile=newfile)
  file.edit(newfile)
}

Nearest Candidate Value

Description

It determines the nearest candidate value for each value in arg. As a replacement for ⁠[base::match.arg]⁠, it is more error-tolerant, but detecting a wrong choice can be proven challenging.

Usage

nearest_arg(arg, choices, method = "cosine", ...)

Arguments

Value

For each value in arg the (first) nearest element of choices.

Examples

# match.arg("tow.sided", c("two.sided", "less", "greater")) # will fail
nearest_arg("tow.sided", c("two.sided", "less", "greater")) 
nearest_arg(c("two.sided", "less", "greater"), c("two.sided", "less", "greater"))
nearest_arg(c("two", "two", "ded", "ss", "ea"), c("two.sided", "less", "greater"))

Association and Correlation

Description

Computation of the following association and correlation measures:

• nom.cc (corrected) contingency coefficient

• nom.cramer Cramer's V or Phi

• ord.spearman Spearman's rank correlation

• ord.kendall Kendall's rank correlation

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

Value

numeric

Examples

tab <- matrix(round(10*runif(15)), ncol=5)
nom.cc(tab)
nom.cc(tab, correct=TRUE)
nom.cramer(tab)
ord.spearman(tab)
ord.kendall(tab)

Sanitization

Description

nosanitize makes no sanitization on the strings.

Usage

nosanitize(str)

Arguments

Value

A sanitized character vector.

Examples

nosanitize("Test")

Current Time

Description

Returns a time stamp based on the current time. now basically calls gsub('.', '', sprintf('%.20f', as.numeric(Sys.time())), fixed=TRUE). To ensure that at each call a different time stamp is delivered now may call gsub(...) several times until two different results are delivered. The last one is then returned.

Usage

now(last = 35)

Arguments

Value

A character.

Examples

now()   # returns all digits
now(3)  # returns only the first three digits

sprintf with template depending on integer valued n

Description

nsprintf creates a text dependent on the value(s) in n. In particular, we have

• round_de, it returns either ⁠Runden Sie Ihr Ergebnis auf eine ganze Zahl⁠, ⁠Runden Sie Ihr Ergebnis auf eine Stelle nach dem Komma⁠, or ⁠Runden Sie Ihr Ergebnis auf n Stellen nach dem Komma⁠

• schoice_de returns ⁠Es kann eine oder mehrere Antworten richtig sein. Es ist ausreichend, eine richtige Antwort anzugeben. Geben Sie mehrere Antworten an und eine ist falsch, dann ist die Aufgabe falsch beantwortet⁠

Usage

nsprintf(n, ...)

round_de(n)

schoice_de()

print_de(n, ...)

Arguments

Value

sprintfed strings

Examples

nsprintf(0, '0' = "keine Netzunterbrechung", '1' = "eine Netzunterbrechung", 
            "%i Netzunterbrechungen")
nsprintf(0:3, `0` = "keine Netzunterbrechung", `1` = "eine Netzunterbrechung", 
              "%i Netzunterbrechungen")

Number to String Conversion

Description

Converts a set of numeric variables to a list as string representation, either as decimal or as a fractional number.

Usage

num2str(..., denom = -1)

Arguments

Value

A list.

Examples

x <- 1
l <- num2str(x)         # returns in l$x the string representation
l <- num2str(x, y=x+1)  # returns in l$x and l$y the string representations

Numeric Rounding List

Description

num_result creates a list with the following elements:

• x the original values

• fx the rounded values with exams::fmt() as a character

• tolerance the tolerance

• digits the digits used for rounding

Note that x may contain more than one numeric value to determine the rounding and tolerance. Make sure that you use for numeric exercises ...$x[1].

If digits are not given and length(x)>1 then ceiling(-log10(min(diff(sort(x)), na.rm=TRUE))) is used. If digits are not given and length(x)==1 then 3+ceiling(-log10(abs(x))) is used. If no tolerance is given then tolmult*10^(1-digits) is used.

int_result can be used if the result is an integer number and calls num_result(x, 0, 0.1, 1, ...) with a tolerance of 0.1.

Usage

num_result(x, digits = NULL, tolerance = NULL, tolmult = 2, ...)

int_result(x, ...)

num_res(x, digits = NULL, tolerance = NULL, tolmult = 2, ...)

int_res(x, ...)

Arguments

Value

A list.

Examples

# height for german man (in meter)
x <- rnorm(10, mean=1.8, sd =0.25)
num_result(c(mean(x), x), digits=2)
int_result(mean(x))
#
str(num_result(pi, 3))
str(num_result(pi, 6))
str(num_result(pi, 6, tolmult=5))
str(num_result(pi, 6, tolmult=5, tolerance=1e-6))

Target Variable Value

Description

Given a set of equations and some variables, num_solve tries to compute the value of the target variable. The equations y=f(x) are transformed to f(x)-y and the functions try to compute the roots of the equations using [stats::uniroot()]. If the computation fails, then, numeric(0) is returned, otherwise the "original" value. If target=='' then all computed values and steps are returned. The attribute compute contains a data frame.

toLatex.equation_solve returns a LaTeX representation of the solution way found by num_solve().

Usage

num_solve(target, eqs, tol = 1e-06)

## S3 method for class 'equation_solve'
toLatex(object, ...)

sequation(target, eqs, tol = 1e-06)

Arguments

Value

(for num_solve) Returns numeric(0), numeric(1), or a list of all (computed) values.

(For toLatex.equation_solve) A character vector.

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"                   
               )
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)
# Find the confidence interval length
ns <- num_solve('l', e)
# Compute everything that is possible
 ns <- num_solve('', e)
toLatex(ns)

Density Function

Description

Creates a linear (power=1) or constant (power=0) density function in a interval

[a, b]

where a and b are sampled from x. It samples size elements without replacement and computes the value of the distribution function.

Usage

pdensity(x, size = 3, power = 1, tol = 1e-06)

sample_density(x, size = 3, power = 1, tol = 1e-06)

Arguments

Value

A list with:

• a the minimum of the interval

• i the maximum of the interval

• x the size sampled values

• fx the distribution function at x

• pcoeff a polynomial (intercept = first value)

• qcoeff indefinite integral of the polynomial (intercept = first value)

• pint result of the integral(pcoeff, c(a,b), 0:2)

Examples

pdensity(-5:5)
pdensity(-5:5, power=1)

Pearson Data

Description

Generates an integer data set for computing a correlation using sumofsquares(). If n>100 and nmax>6 it is better to use one of the precomputed solutions. Otherwise it may take up to maxt seconds. Please note that the correlation of the generated data set may differ from the desired correlation.

Usage

pearson_data(r, n = 100, nmax = 6, maxt = 30, xsos = NULL, ysos = NULL)

dpearson(r, n = 100, nmax = 6, maxt = 30, xsos = NULL, ysos = NULL)

Arguments

Value

A matrix with two columns and an attribute interim for intermediate values as matrix. The rows of the matrix contain : x_i, y_i, x_i-bar{x}, y_i-\bar{y}, (x_i-bar{x})^2, (y_i-\bar{y})^2, and (x_i-bar{x})((y_i-\bar{y}). In a final step, a vector with the row of sums is appended as a further column.

Examples

data(sos)
xy <- pearson_data(0.7, xsos=sos100)
colSums(xy)
colSums(xy^2)
sum(xy[,1]*xy[,2])
# my data
x <- 100+5*xy[,1]
y <- 100+5*xy[,2]
cor(x, y)

Polynomial Minimum

Description

Computes the minimum of a polynomial in the interval [lower, upper]. The values and the interval borders of the polynomial p are evaluated and the minimum value is returned.

Usage

pminimum(
  p,
  interval,
  lower = min(interval),
  upper = max(interval),
  tol = 1e-09
)

polynomial_minimum(
  p,
  interval,
  lower = min(interval),
  upper = max(interval),
  tol = 1e-09
)

Arguments

Value

The minimal function value.

Examples

p <- polynomial(c(-5, 3, -3, 1))
pminimum(p, -3, 3)

Interval Ranges

Description

Generates intervals based on powers of ten.

Usage

pos(pow)

neg(pow)

dbl(pow)

idbl(pow)

ipos(pow)

ineg(pow)

Arguments

Value

A numeric object.

Examples

dbl(2)
dbl(3)
pos(3)
neg(3)

Polynomial Probability

Description

Creates for each value of a discrete random variable, a polynomial and estimates the least squares and the maximum likelihood solution. The following conditions stand:

• If sample is not given then the sample contains each x value once.

• If sample is an integer, then it is interpreted as the sample size and a sample is generated by rmultinom(1, sample, ddiscrete(runif(length(x)))).

• If sample is a vector, it is interpreted in such a way that the corresponding x[i] value occurs i times in the sample. Thus, sum(sample) is the sample size.

• If coeff is a polylist of length(x), then these polynomials are taken.

• If coeff is a matrix with length(x), columns and power+1 rows, then the columns are interpreted as the coefficients of a polynomial.

• Otherwise coeff is interpreted as a vector from which the coefficient is sampled. The intercepts are sampled via ddiscrete(runif(length(x)), zero=zero). If coeff is not given then it is ensured that the least squares and the maximum likelihood solution exists and the estimated probabilities are between zero and one. Otherwise, the results may contain NA or the estimated probabilities are outside the interval [0;1].

Usage

pprobability(
  x,
  power = 1,
  zero = FALSE,
  coef = round(seq(-1, 1, by = 0.1), 1),
  sample = rep(1, length(x)),
  pl = NULL,
  tol = 1e-09
)

polynomial_probability(
  x,
  power = 1,
  zero = FALSE,
  coef = round(seq(-1, 1, by = 0.1), 1),
  sample = rep(1, length(x)),
  pl = NULL,
  tol = 1e-09
)

Arguments

Value

A list with the components:

• p: the polynomials for the probabilities

• ep: the expected value as polynomial

• x: the values for the discrete random variable, the same as the input x

• sample: the sample given or generated

• LS$pi: the summands for the least squares problem

• LS$pl: the summands for the least squares problem in LaTeX

• LS$pf: the sum of LS$pi

• LS$df: the derivative of LS$pf

• LS$pest: the estimated parameter, minimum of LS$pf

• LS$p: the estimated probabilities

• ML$pi: the factors for the maximum likelihood problem

• ML$pl: the summands for the maximum likelihood problem in LaTeX

• ML$pf: the product of ML$pi

• ML$df: the derivative of ML$pf

• ML$pest: the estimated parameter, maximum of ML$pf

• ML$p: the estimated probabilities

Examples

# linear polynomials
pprobability(0:2)
pprobability(0:2, power=1)
# constant polynomials, some NAs are generated
pprobability(0:3, power=0)
# polynomials generated from a different set
pprobability(0:2, coef=seq(-2, 2, by=0.1))
pprobability(0:2, 0, coef=seq(-2, 2, by=0.1))
# polynomials (x, x, 1-2*x) are used
pprobability(0:2, 0, coef=matrix(c(0.4, 0.4, 0.3), ncol=3))
pprobability(0:2, 1, coef=polylist(c(0,1), c(0,1), c(1, -2)))

print.equations

Description

Prints an equations object with equations and variables. Internally, a data frame is generated, created and printed.

Usage

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

Arguments

Value

The data frame invisibly generated.

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)

Print html_matrix

Description

Prints an HTML matrix content or its components.

Usage

## S3 method for class 'html_matrix'
print(x, ..., which = "")

Arguments

Value

An invisible character matrix.

Examples

m <- matrix(1:6, ncol=2)
l <- html_matrix_sk(m, title="1 to 6", fmt=rep("%f",ncol(m)))
print(l, which=NA)      # returns full style information
print(l, which="fmt")   # returns format information
print(l, which="value") # identical to print(l)

Total or Conditional Probability Computation

Description

The following functions are available:

• prob_solve given a set of events it computes the total or conditional probability of the given event or NA if no solution could be found. For the naming of the events upper case letters must be used and the available operators are ! (complementary event), | (conditional event), and ^ (intersection of events). The attribute latex of the return value contains the necessary computation steps for computation of the given event. If getprob is TRUE then additionally the attribute prob, a vector with all computed probabilities, and compute, which includes all computational steps, are generated.

• print shows the solution way in ASCII.

• toLatex shows the solution way in LaTeX/MathJax with an align environment.

• lprob converts !A to ⁠\\bar{A}⁠ and A^B to ⁠A \\cap B⁠.

Usage

prob_solve(target, ...)

## Default S3 method:
prob_solve(target, ..., partition = NULL, getprob = FALSE, quiet = TRUE)

lprob(txt)

## S3 method for class 'prob_solve'
toLatex(object, ...)

## S3 method for class 'prob_solve'
print(x, type = c("numeric", "latex", "prob", "compute"), ...)

latex_prob(txt)

probability_solution(target, ...)

sprob(target, ...)

Arguments

Details

The program applies iteratively the following rules to find a solution:

• P(A) = 1-P(!A),

• P(A|B) = 1-P(!A|B),

• P(A^B) = P(B^A),

• P(B) = P(A^B)+P(!A^B),

• P(A|B) = P(A^B)/P(B), and

• P(A) = P(A|P1)+P(A|P2)+...+ P(A|Pn) for a partition P1, P2, ..., Pn.

Value

An object of the class prob_solve with the resulting probability, including the steps for computing. If NA is returned then no solution could be found.

Examples

prob_solve("!A", "A"=0.3)
prob_solve("!A|B", "A|B"=0.3)
prob_solve("B^A", "A^B"=0.3)
# P(B)   = P(A^B)+P(!A^B)
prob_solve("B", "A^B"=0.3, "!A^B"= 0.4)
prob_solve("A^B", "B"=0.7, "!A^B"= 0.4)
prob_solve("!A^B", "B"=0.7, "A^B"= 0.3)
# P(A|B) = P(A^B)/P(B)
prob_solve("A|B", "A^B"=0.3, "B"= 0.6)
prob_solve("A^B", "B"=0.6, "A|B"= 0.5)
prob_solve("B", "A|B"=0.5, "A^B"= 0.3)
#' latex, prob and compute attributes
pmt <- prob_solve("M|T", "M"=0.6, "T|M"=0.75, "T|!M"=0.39, quiet=FALSE, getprob=TRUE)
toLatex(pmt)
attr(pmt, "latex")
pmt <- prob_solve("M|T", "M"=0.6, "T|M"=0.75, "T|!M"=0.39, quiet=FALSE, getprob=TRUE)
attr(pmt, "prob")
print(pmt, "latex") 
print(pmt, "prob")    # only if getprob=TRUE   
print(pmt, "compute") # only if getprob=TRUE   
# bayes theorem and total probability
prob_solve("Z", "Z|A"=0.1, "Z|B"=0.2, "Z|C"=0.3, partition=c("A", "B", "C"))
prob_solve("Z|A", "Z"=0.6, "Z|B"=0.2, "Z|C"=0.3, partition=c("A", "B", "C"))
prob_solve('A|K', "A"=0.55, "B"=0.35, "C"=0.1, "K|A"=0.4, "K|B"=0.1, "K|C"=0.1, 
           partition=c("A", "B", "C"))
prob_solve('K', "A"=0.55, "B"=0.35, "C"=0.1, "K|A"=0.4, "K|B"=0.1, "K|C"=0.1, 
           partition=c("A", "B", "C"))

Binomial Test Data Creation

Description

Creates data for a binomial test based on the properties for the test.

Usage

proptest_data(
  size = 10:100,
  prob = seq(0.05, 0.45, by = 0.05),
  reject = TRUE,
  alternative = c("two.sided", "less", "greater"),
  alpha = c(0.01, 0.05, 0.1),
  norm.approx = NA,
  maxit = 1000
)

prop_binomtest_data(
  size = 10:100,
  prob = seq(0.05, 0.45, by = 0.05),
  reject = TRUE,
  alternative = c("two.sided", "less", "greater"),
  alpha = c(0.01, 0.05, 0.1),
  norm.approx = NA,
  maxit = 1000
)

dbinomtest(
  size = 10:100,
  prob = seq(0.05, 0.45, by = 0.05),
  reject = TRUE,
  alternative = c("two.sided", "less", "greater"),
  alpha = c(0.01, 0.05, 0.1),
  norm.approx = NA,
  maxit = 1000
)

Arguments

Value

A list with the components:

• pi0 hypothetical proportion

• x counts of successes in the sample

• n sample size

• alpha significance level

• alternative specifying the alternative hypothesis (either two.sided, greater or less)

Examples

proptest_data()

Proportion Tests

Description

Computes all results for test on proportion using either stats::binom.test(), or a normal approximation without continuity correction. Either named parameters can be given or an arglist with the following parameters:

• x number of successes

• n sample size (default: sd(x))

• pi0 true value of the proportion (default: 0.5)

• alternative a string specifying the alternative hypothesis (default: "two.sided"), otherwise "greater" or "less" can be used

• alpha significance level (default: 0.05)

• binom2norm can the binomial distribution be approximated by a normal distribution? (default: NA = use binom2norm function)

Usage

proptest_num(..., arglist = NULL)

prop_binomtest_num(..., arglist = NULL)

nbinomtest(..., arglist = NULL)

Arguments

Details

The results of proptest_num may differ from stats::binom.test(). proptest_num is designed to return results when you compute a binomial test by hand. For example, for computing the test statistic the approximation t_n \approx N(0; 1) is used if n>n.tapprox. The p.value is computed by stats::binom.test and may not be reliable, for Details see Note!

Value

A list with the input parameters and the following:

• X distribution of the random sampling function

• Statistic distribution of the test statistics

• statistic test value

• critical critical value(s)

• criticalx critical value(s) in x range

• acceptance0 acceptance interval for H0

• acceptance0x acceptance interval for H0 in x range

• accept1 is H1 accepted?

• p.value p value for test (note: the p-value may not be reliable see Notes!)

• alphaexact exact significance level

• stderr standard error of the proportion used as denominator

Note

The computation of a p-value for non-symmetric distribution is not well defined, see https://stats.stackexchange.com/questions/140107/p-value-in-a-two-tail-test-with-asymmetric-null-distribution.

Examples

n <- 100
x <- sum(runif(n)<0.4)
proptest_num(x=x, n=n)

Proportion Tests

Description

proptests runs a bunch of modifications of the input parameters of proptest to generate all possible proportion tests. See under "Details" the detailed parameter values which are used. Note that not giving the parameter hyperloop will results in several hundred tests generated. Only the distinct tests will be returned, with the first element being proptest. If only a specific element of a proptests is of interest, provide the name of the element in elem. All proptests will then be returned where the value of elem is different.

Usage

proptests(proptest, elem = NULL, hyperloop = NULL)

Arguments

Details

The default hyperloop is:

list(x           = c(proptest$x, proptest$n-proptest$x)
     pi0         = c(proptest$pi0, 1-proptest$pi0, proptest$x/proptest$n, 1-proptest$x/proptest$n)
     alpha       = unique(c(proptest$alpha, 0.01, 0.05, 0.1)),
     alternative = c("two.sided", "greater", "less")
   )

Value

list of proptest objects is returned

Examples

basetest  <- proptest_num(x=3, n=8, alternative="greater")
# vary the number of observations
hyperloop <- list(pi0 = c(basetest$pi0, 1-basetest$pi0, 
                          basetest$x/basetest$n, 1-basetest$x/basetest$n))
# return all different tests
tts       <- proptests(basetest, hyperloop=hyperloop)
# return all different random sampling functions
proptests(basetest, "X", hyperloop)

Mean and Standard Deviation for Normal Distribution

Description

Given two (or more) quantiles it computes an (approximate) mean and standard deviation for a corresponding normal distribution.

Usage

q2norm(x, probs = c(0.025, 0.975))

Arguments

Value

A list with a component mean and sd.

Examples

q2norm(c(100,200))

Random

Description

Returns a index from 1:length(v) randomly ordered.

Usage

random(v)

rand(v)

Arguments

Value

Index

Examples

random(-3:3)

Generate Vector Element Names

Description

Creates names for elements of a vector.

Usage

refer(x, fmt = "%s_{%.0f}", to = deparse(substitute(x)), index = 1:length(x))

refer2vector(
  x,
  fmt = "%s_{%.0f}",
  to = deparse(substitute(x)),
  index = 1:length(x)
)

Arguments

Value

A character vector

Examples

x <- runif(5)
refer(x)                  # LaTeX default
refer(x, fmt="%s[%.0f]")  # R default

Replace

Description

In a text it replaces names with:

• values which are formatted with exams::fmt(), or

• strings

Usage

replace_fmt(txt, digits = 2L, ...)

Arguments

Value

A character with replaced names.

Examples

replace_fmt("\\frac{x}{y}", x=2, y=3)
replace_fmt("\\frac{x}{y}", x=2, y=3, digits=0)
replace_fmt("\\frac{x}{y}", x=2, y=3, digits=list(0))
replace_fmt("\\frac{x}{y}", x=2, y=3, digits=list(2, y=0))
replace_fmt("\\frac{x}{y}", x="\\\\sum_{i=1}^n x_i", y="\\\\sum_{i=1}^n y_i")

Random Variable

Description

Formats a random variable and its meaning for R Markdown.

Usage

rv(symbol, explanation)

rmdFormatRV(symbol, explanation)

lrv(symbol, explanation)

Arguments

Value

A formatted string.

Examples

rv("X", "Waiting time in minutes until next event")

Sample Size Consistency Checker

Description

Checks if a vector of possible sample sizes and relative frequencies create integer absolute frequencies.

Usage

sample_size_freq(n, f, which = NA)

dnsizefreq(n, f, which = NA)

Arguments

Value

One sample size.

Examples

f <- ddiscrete(runif(5), unit=100)
sample_size_freq(seq(10, 200, 1), f)
sample_size_freq(seq(10, 200, 1), f, which=200)

Rescaling

Description

Rescales x such that for the rescaled data it holds: mean(scale_to(x, mean=target))==target and sd(scale_to(x, sd=target)==abs(target). A negative value of sd will change the sign of the x values.

Usage

scale_to(x, mean = 0, sd = 1)

Arguments

Value

Rescaled data.

Examples

x <- runif(50)
y <- scale_to(x, mean=0.1, sd=0.2)
mean(y)
sd(y)
y <- scale_to(x, mean=0.1, sd=-0.2)
mean(y)
sd(y)

Skalenniveau

Description

A data frame with the variables and level of measurement type. The names are in German.

Usage

data(skalenniveau)

Format

A data frame with columns var, and type.

Examples

data(skalenniveau)
head(skalenniveau)

Solutions

Description

Creates a solution object and prints a meta information block for the following:

• solution the default is sol_num

• sol_num for a numerical solution

• sol_int for an integer solution

• sol_mc for a multiple choice solution

• sol_ans for the answer list of a multiple choice solution

• sol_tf for the solution list (True or False) of a multiple choice solution

• sol_info for creating a Meta-Information block

Usage

solution(x, ...)

## Default S3 method:
solution(x, ...)

sol_int(x, tol = NA, digits = NA)

sol_num(x, tol = NA, digits = NA)

sol_mc(x, y, sample = NULL, shuffle = order, none = NULL)

sol_ans(x, ...)

sol_tf(x, ...)

sol_info(x, ...)

sol_mc_ans(x, ...)

sol_meta(x, ...)

sol_mc_tf(x, ...)

Arguments

Details

For numerical solutions you can set tol and/or digits. If they are not set, they are automatically selected. If tol is not set and length(x)>1 then the tolerance is chosen as min(diff(sort(x)))/2. Otherwise, as max(0.001, 0.001*abs(x)). I If tol is negative, tolerance is set to 10^tol, otherwise it is used as it is. If digits is not set, ceiling(-log10(tolerance)) is used.

Value

A solution object.

Examples

s <- sol_num(pi)
sol_info(s)
# set same tolerances, e.g. for a probability
sol_num(0.1)
sol_num(0.1, tol=0.001)
sol_num(0.1, tol=-3)
# MC: Which are prime numbers?
prime <- c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)
nonprime <- setdiff(2:30, prime)
# choose five false and two correct solutions
s <- sol_mc(nonprime, prime, sample=c(5,2), none="There are no prime numbers in the list")  
sol_ans(s)
sol_tf(s)
sol_info(s)

Precomputed Sum of Squared Data

Description

Five data matrices with precomputed results from sumofsquares(n, 10, zerosum=TRUE, maxt=Inf) for n=100, n=200, n=400,n=800, and n=1000.

Usage

data(sos)

sos200

sos400

sos800

sos1000

Format

For each line of a matrix it holds \sum_{i=1}^k x_i^2=n and \sum_{i=1}^k x_i=0. It contains all integer solutions up to k<=10. NA means that this entry is not used.

Examples

data(sos)
head(sos100)
rowSums(sos100^2, na.rm=TRUE)
rowSums(sos100, na.rm=TRUE)

RMarkdown Spell Check

Description

Performs a spell check on RMarkdown files ignoring some exams keywords using spelling::spell_check_files().

Usage

spell(
  path,
  ignore = c("Meta", "information", "extype", "num", "mchoice", "schoice", "Solution",
    "exsolution", "extol", "exname", "Question", "align", "begin", "bigg", "cases",
    "cdot", "end", "frac", "infty", "int", "left", "left.", "leq", "mu", "qquad",
    "right", "sum", "text", "vert"),
  lang = Sys.getenv("LANG")
)

rm_spell_check(
  path,
  ignore = c("Meta", "information", "extype", "num", "mchoice", "schoice", "Solution",
    "exsolution", "extol", "exname", "Question", "align", "begin", "bigg", "cases",
    "cdot", "end", "frac", "infty", "int", "left", "left.", "leq", "mu", "qquad",
    "right", "sum", "text", "vert"),
  lang = Sys.getenv("LANG")
)

Arguments

Value

A data frame with problematic words.

Examples

# none

Calculating Square Roots of np(1-p) Combinations

Description

Computes sqrt(n*p*(1-p)) for all combinations of n and p. If the result has only digits after the decimal point, then n, p, and sqrt(n*p*(1-p)) are returned in a data frame.

Usage

sqrtnp(n, p, digits = 2, tol = 10^(-digits - 4))

Arguments

Details

If abs(v-round(v, digits))<tol then a number v is considered as a number with only digits after the decimal point.

Value

A data frame with the columns n, p, np (=np) and snp (=sqrt(np(1-p))).

Examples

n <- 30:250
p <- (10:40)/100
sqrtnp(n, p)

Sum of Squared Integers

Description

Decomposes an integer n into a sum of squared integers (n = \sum_{i=1}^k x_i^2; 1\leq x_i <n) with k\leq nmax. If zerosum is true then it is ensured that \sum_{i=1}^k c_i x_i = 0 with c_i=-1 or c_i=+1. The computation of the x_i's is limited by maxt seconds, which may result that not all possible solutions are found. To reduce computing time, rbind's in the function are replaced by allocating matrices with size rows to fill in the results. Note that the following data sets are available:

• sos100=sumofsquares(100, 10, zerosum=TRUE, maxt=Inf),

• sos200=sumofsquares(200, 10, zerosum=TRUE, maxt=Inf),

• sos400=sumofsquares(400, 10, zerosum=TRUE, maxt=Inf),

• sos800=sumofsquares(800, 10, zerosum=TRUE, maxt=Inf), and

• sos1000=sumofsquares(100, 10, zerosum=TRUE, maxt=Inf)

Usage

sumofsquares(n, nmax = 10, zerosum = FALSE, maxt = 30, size = 100000L)

sum_sq(n, nmax = 10, zerosum = FALSE, maxt = 30, size = 100000L)

Arguments

Value

A matrix with nmax column with x_i's. NA means number has not been used.

Examples

sos <- sumofsquares(100, 6) # 23 solutions
head(sos)
table(rowSums(!is.na(sos))) 
# one solution with one or two x_i
# five solutions with four x_i
# six solutions with five x_i
# ten solutions with six x_i
rowSums(sos^2, na.rm=TRUE)  # all 100
sos <- sumofsquares(100, 6, zerosum=TRUE)
head(sos)
rowSums(sos^2, na.rm=TRUE)  # all 100
rowSums(sos, na.rm=TRUE)    # all 0 

sumofsquares1

Description

Decomposes an integer n2 into a sum of squared integers (n2 = \sum_{i=1}^{nobs} x_i^2). If n is not NA then it is ensured that \sum_{i=1}^{nobs} x_i = 0. Note if nobs<=10 then the following data sets are available:

• sos100=sumofsquares(100, 10, zerosum=TRUE, maxt=Inf),

• sos200=sumofsquares(200, 10, zerosum=TRUE, maxt=Inf),

• sos400=sumofsquares(400, 10, zerosum=TRUE, maxt=Inf),

• sos800=sumofsquares(800, 10, zerosum=TRUE, maxt=Inf), and

• sos1000=sumofsquares(100, 10, zerosum=TRUE, maxt=Inf)

Usage

sumofsquares1(n2, nobs = 10, n = 0, x = runif(nobs), maxit = 1000)

Arguments

Value

A integer vector of length nobs.

Examples

sumofsquares1(100, 20)
sumofsquares1(100, 20)

Approximations

Description

Functions which deliver TRUE or FALSE if any approximation if possible. The approximation parameter c can be set directly, or it can be given via getOption. The approximation functions deliver TRUE in the following scenarios:

• t2norm: n>c with c=30

• binom2norm: if the type is "single" (default) then it checks ⁠size × prob (1-prob)>c⁠, or else it checks ⁠size × prob>c⁠ and ⁠size × (1-prob)>c⁠ with c=9

• clt2norm: n>c with c=30. Note that the existence of the expectation and variance, which are required by the Central Limit Theorem, cannot be checked. “

Usage

t2norm(n, c = getOption("distribution.t2norm", 30))

binom2norm(
  size,
  prob,
  c = getOption("distribution.binom2norm", 9),
  type = c("single", "double")
)

clt2norm(n, c = getOption("distribution.clt2norm", 30))

approx_binom2norm(
  size,
  prob,
  c = getOption("distribution.binom2norm", 9),
  type = c("single", "double")
)

approx_clt2norm(n, c = getOption("distribution.clt2norm", 30))

approx_t2norm(n, c = getOption("distribution.t2norm", 30))

Arguments

Value

logical if the approximation would be possible

Examples

# check for 5 observations
t2norm(n=c(5,50))
binom2norm(size=c(5,50), prob=0.5)
binom2norm(size=c(5,50), prob=0.5, type="double")

Frequency Table

Description

Creates a frequency table where all entries can be written as 2^{p_{ij}} 5^{q_{ij}}. It holds that p_{ij}<m2 and q_{ij}<m5. If the algorithm does not find a solution, then an error is thrown. Try to increase unit to 20, 50, 100 and so on. Once a table is found, the table is normalized by dividing all entries by a number such that the entries are still integer. Finally, a multiplicator of the form 2^p 5^5 is randomly chosen, ensuring that the sum of the entries is less than, or equal to n.

Usage

table_data(
  nrow,
  ncol,
  unit = 10,
  maxit = 1000,
  n = 100,
  m2 = ceiling(log(n)/log(2)),
  m5 = ceiling(log(n)/log(5))
)

freq_table(
  nrow,
  ncol,
  unit = 10,
  maxit = 1000,
  n = 100,
  m2 = ceiling(log(n)/log(2)),
  m5 = ceiling(log(n)/log(5))
)

dtable(
  nrow,
  ncol,
  unit = 10,
  maxit = 1000,
  n = 100,
  m2 = ceiling(log(n)/log(2)),
  m5 = ceiling(log(n)/log(5))
)

Arguments

Value

A frequency table where all entries can be written as 2^{p_{ij}} 5^{q_{ij}}.

Examples

tab22 <- table(2, 2)
tab22
divisor_25(tab22)
nom.cc(tab22)         # Should be zero
#
table(3, 2)
table(4, 2)

Template

Description

A text template where R code can be embedded.

Usage

template(tmpl, ...)

Arguments

Value

A character where the R code is replaced by its evaluation.

Examples

tmpl <- "`r a`+`r b`"
template(tmpl, a=1, b=2)

HTML and LaTeX Matrix Representations

Description

• toHTML returns an HTML representation of a matrix and, optionally, shows the result in the browser. If you decide to view the result in a browser then the HTML will be written to a temporary file and utils::browseURL() will be called

• toLatex returns a LaTeX representation of a matrix, but supports just a small subset of style options

• toHTMLorLatex returns an HTML or LaTeX representation of a matrix, depending if exams2pdf is in the call list or not

Usage

## S3 method for class 'html_matrix'
toHTML(x, browser = FALSE, ...)

## S3 method for class 'html_matrix'
toLatex(object, ...)

toHTMLorLatex(x, ...)

Arguments

Value

character

Examples

library("tools")
m    <- matrix(1:12, ncol=4)
hm   <- html_matrix(m)
if (interactive()) html <- toHTML(hm, browser=TRUE)
toHTML(hm)
toLatex(hm)

LaTeX Representation of a Polynomial

Description

Returns a LaTeX representation of the polynomial.

Usage

## S3 method for class 'polynomial'
toLatex(
  object,
  digits = TRUE,
  decreasing = FALSE,
  variable = "x",
  simplify = TRUE,
  tol = 1e-09,
  ...
)

Arguments

Value

A character

Examples

p <- polynomial(c(-1,0,2)/3)
toLatex(p, 4)
toLatex(p, FALSE)
toLatex(p, TRUE)
toLatex(p, variable="z")
toLatex(p, decreasing=TRUE)
p <- polynomial(c(0,1,2)/3)
toLatex(p)
toLatex(p, tol=-1)

toRMarkdown

Description

Conversion to R Markdown.

Usage

toRMarkdown(txt)

Arguments

Value

Lines with RMarkdown

Examples

txt <- c("[image]\n",
         "Ein Paar hat 8 gute Bekannte, von denen die beiden 5 zum Essen einladen möchten.",
         "Wie viele verschiedene Reihenfolgen des Eintreffens der eingeladenen 5 Gäste gibt es?\n",
         ": 56",
         "; 120",
         "; 336",
         "; 2002",
         "; 6720",
         "; 32768",
         "; 40320",
         "; Keine Antwort ist richtig")
toRMarkdown(txt)          

Text Representation of a Polynomial

Description

Creates a text representation for a polynomial, in the following scenarios:

• if digits is TRUE then as.character(.) is used

• if digits is FALSE then ./. is used

• if digits is numeric then as.character(round(., digits)) is used

Usage

## S3 method for class 'polynomial'
toString(
  x,
  digits = TRUE,
  decreasing = FALSE,
  variable = "x",
  simplify = TRUE,
  tol = 1e-09,
  ...
)

Arguments

Value

A character

Examples

p <- polynomial(c(-1,0,2)/3)
toString(p, 4)
toString(p, FALSE)
toString(p, TRUE)
toString(p, variable="z")
toString(p, decreasing=TRUE)
p <- polynomial(c(0,1,2)/3)
toString(p)
toString(p, tol=-1)

Questions and Solutions List Generation

Description

Creates a list with the elements questions and solutions values. A value can be either an entry in a vector or a row in a data frame. correct is a logical vector which contains TRUE if its value represents a correct answer and FALSE if it represents a wrong answer. The values can be shuffled or ordered (default).

If shuffle is a integer of length 1 then one correct answer is chosen, and shuffle wrong answers are chosen. If shuffle is a integer of length larger than 1, then shuffle[1] correct answers are chosen and shuffle[2] wrong answers are chosen. If any shuffle entry is zero or negative, then no shuffling will be done. If order is a function then it is expected that the function delivers an index for the reordering of the values. Otherwise a shuffle for all values is applied.

The shuffling works in two steps:

1. Sample within the correct and wrong value according to shuffle

2. Apply shuffling (order=NULL) or ordering (default: order=order) of all selected answers

Usage

to_choice(
  df,
  correct,
  shuffle = c(NA_integer_, NA_integer_),
  orderfun = order,
  ...
)

choice_list(
  df,
  correct,
  shuffle = c(NA_integer_, NA_integer_),
  orderfun = order,
  ...
)

Arguments

Value

list with questions and solutions

Examples

answer   <- runif(5)
correct  <- (1:5)==3 # Third answer is correct, the rest wrong
sc       <- to_choice(answer, correct)
str(sc)           # Answers are ordered by size
sc$questions <- c(format(sc$questions, nsmall=2), "No answer is correct") # Additional answer
sc$solutions <- c(sc$solutions, FALSE)                                    # TRUE or FALSE?
sc           <- to_choice(answer, correct, shuffle=2)
str(sc)      # One correct answer and two wrong answers selected

Tooltip

Description

Adds a text tooltip to the HTML matrix.

Usage

tooltip(x, tooltip = NULL)

add_tooltip(x, tooltip = NULL)

Arguments

Value

An html_matrix object

Examples

library("magrittr")
library("tools")
m    <- matrix(1:12, ncol=4)
hm   <- html_matrix_sk(m, title='', fmt=rep("%f", ncol(m))) %>% 
          add_tooltip(sprintf("Table has %0.f rows and %0.f columns", nrow(.), ncol(.)))
if (interactive()) html <- toHTML(hm, browser=TRUE)

Transformation

Description

Transforms x if cond is TRUE by \log(a+b*x) if p==0 and (a+b*x)^p). Otherwise the transformation can be either applied to each element of x, or to all elements of x.

Usage

transformif(x, cond, a = -abs(min(x)), b = 1, p = 1)

Arguments

Value

A transformed vector

Examples

x <- rnorm(5)
transformif(x, min(x)<0)  # all transformed elements > 0
transformif(x, x<0)       # only negative elements are transformed

Time Series

Description

Creates an univariate time series based on a linear or an exponential trend, an additive or multiplicative seasonal adjustment and with white noise.

Usage

ts_data(
  end,
  trend = TRUE,
  trend.coeff = c(1, 1),
  season = TRUE,
  season.coeff = NULL,
  error = TRUE,
  error.coeff = NULL,
  digits = NA
)

dts(
  end,
  trend = TRUE,
  trend.coeff = c(1, 1),
  season = TRUE,
  season.coeff = NULL,
  error = TRUE,
  error.coeff = NULL,
  digits = NA
)

Arguments

Value

A ts_data object with the following list of elements:

• t the time points

• s the season for the time points

• xt the time series values

Examples

# Time series from linear trend
ts <- ts_data(12, trend.coeff= c(sample(0:10, 1), sample(1+(1:10)/20, 1)))
ts
# Time series from exponential trend
ts <- ts_data(12, trend.coeff= c(sample(0:10, 1), sample(1+(1:10)/20, 1)), trend=FALSE)
ts   
# Time series from linear trend and additive seasonal adjustment (quartely data)
ts <- ts_data(12, trend.coeff=c(sample(0:10, 1), sample(1+(1:10)/20, 1)),
                  season.coeff=sample((-20:20)/20, 4))
ts   
# Time series from linear trend and additive seasonal adjustment (half-yearly data)
ts <- ts_data(12, trend.coeff=c(sample(0:10, 1), sample(1+(1:10)/20, 1)),
                  season.coeff=sample((-20:20)/20, 2))
ts   
# Time series from linear trend and mutliplicative seasonal adjustment (quartely data)
ts <- ts_data(12, trend.coeff=c(sample(0:10, 1), sample(1+(1:10)/20, 1)),
                  season.coeff=sample((-20:20)/20, 4), season=FALSE)
ts   

Moving Average

Description

Computes the moving average for a ts_data object.

Usage

ts_moving_average(ts, order)

ts_ma(ts, order)

Arguments

Value

Returns an extended ts_data object with list elements:

• filter the filter used

• moving.average the computed moving average

Examples

# trend from a quadratic model
ts <- ts_data(12, trend.coeff=c(sample(0:10, 1), sample(1+(1:10)/20, 1), 0.5))
ts_moving_average(ts, 3)

Trend and Season Model

Description

Estimate a trend and season model from a ts_data object.

Usage

ts_trend_season(ts, trend = NULL, season = NULL)

ts_ts(ts, trend = NULL, season = NULL)

Arguments

Value

Returns an extended ts_data object with the following list of elements:

• t the time points

• s the season for the time points

• xt the time series values

• trend the fitted trend values

• trend.coeff the trend coefficients

• trend.linear the trend type, if NA then it is unknown

• season the fitted season values

• season.t the fitted season values for the time series

• trend.season the fitted values for trend and season

• trend.linear the trend type, if NA then it is unknown

• var the variance of the residuals

• r.square the R^2 of the final model

Examples

ts <- ts_data(12, trend.coeff= c(sample(0:10, 1), sample(1+(1:10)/20, 1)))
ts_trend_season(ts)

T-tests and Data Creation

Description

Creates data for a t-test, for one mean, based on the test's properties.

Usage

ttest_data(
  size = (3:20)^2,
  mean = -5:5,
  sd = seq(0.1, 1, by = 0.1),
  reject = NA,
  alternative = c("two.sided", "less", "greater"),
  alpha = c(0.01, 0.05, 0.1),
  z = seq(-4.49, 4.49, by = 0.01),
  use.sigma = TRUE
)

dt1(
  size = (3:20)^2,
  mean = -5:5,
  sd = seq(0.1, 1, by = 0.1),
  reject = NA,
  alternative = c("two.sided", "less", "greater"),
  alpha = c(0.01, 0.05, 0.1),
  z = seq(-4.49, 4.49, by = 0.01),
  use.sigma = TRUE
)

Arguments

Value

A list with the components:

• mu0 hypothetical mean

• sigma standard deviation in the population

• sd vector of possible standard deviations in the sample

• xbar mean in the sample

• n sample size

• alpha significance level

• alternative specifying the alternative hypothesis (either two.sided, greater or less)

• altsd alternative values usable for sd (if use.sigma==TRUE) or sigma (if use.sigma==FALSE)

Examples

ttest_data()

T-tests

Description

Computes all results for a t-test. Note that the results may differ from stats::t.test(), see the "Details". Either named parameters can be given, or a list with the parameters. You must provide either x or mean, sd and n. If x is given then any values given for mean, sd and n will be overwritten. Also either sd or sigma or both must be given.

• x sample (default: numeric(0))

• mean sample mean (default: mean(x))

• n sample size (default: length(x))

• sd sample standard deviation (default: sd(x))

• sigma population standard deviation (default: NA = unknown)

• mu0 true value of the mean (default: 0)

• alternative a string specifying the alternative hypothesis (default: "two.sided"), otherwise "greater" or "less" can be used

• alpha significance level (default: 0.05)

• norm is the population normal distributed? (default: FALSE)

• n.clt when the central limit theorem holds (default: getOption("n.clt", 30))

• t2norm does the approximation t_n \approx N(0;1) hold? ⁠(default: ⁠NA⁠= use⁠t2norm' function)

Usage

ttest_num(..., arglist = NULL)

Arguments

Details

The results of ttest_num may differ from stats::t.test(). ttest_num is designed to return results when you compute a t-test by hand. For example, for computing the test statistic the approximation t_n \approx N(0; 1) is used if n>n.tapprox. The p.value is computed from the cumulative distribution function of the normal or the t distribution.

Value

A list with the input parameters and the following:

• Xbar distribution of the random sampling function \bar{X}, only available if sigma given

• Statistic distribution of the test statistics

• statistic test value

• critical critical value(s)

• criticalx critical value(s) in x range

• acceptance0 acceptance interval for H0

• acceptance0x acceptance interval for H0 in x range

• accept1 is H1 accepted?

• p.value p value for test

Examples

x <- runif(100)
ttest_num(x=x)
ttest_num(mean=mean(x), sd=sd(x), n=length(x))
ret <- ttest_num(x=x)
ret$alternative <- "less"
ttest_num(arglist=ret)

T-tests

Description

ttests runs a variety of modifications to the input parameters of ttest, in order to generate all possible t-tests. See under "Details" the detailed parameter values which are used. Note that not giving the parameter hyperloop will results in approx. 5000 t-tests generated. Returned will be only the different t-tests with the first element being ttest. If only a specific element of a ttest is of interest then just give the name of the element in elem and then all ttests will be returned where elem is different.

Usage

ttests(ttest, elem = NULL, hyperloop = NULL)

Arguments

Details

The default hyperloop is:

list(n           = c(1, ttest$n, ttest$n+1),
     mu0         = c(ttest$mu0, ttest$mean),
     mean        = c(ttest$mu0, ttest$mean), 
     sigma       = c(ttest$sigma, ttest$sd, sqrt(ttest$sigma), sqrt(ttest$sd)),
     sd          = c(ttest$sigma, ttest$sd, sqrt(ttest$sigma), sqrt(ttest$sd)),
     norm        = c(TRUE, FALSE),
     alpha       = unique(c(ttest$alpha, 0.01, 0.05, 0.1)),
     alternative = c("two.sided", "greater", "less")
    )

Value

A list of ttest objects is returned

Examples

basetest  <- ttest_num(mean=0.5, sd=1.25, n=50, sigma=1)
# vary the number of observations
hyperloop <- list(n=c(1, basetest$n, basetest$n^2))
# return all different t-tests
tts       <- ttests(basetest, hyperloop=hyperloop)
# return all different random sampling functions
ttests(basetest, "Xbar", hyperloop)

Unique Elements

Description

Deletes all elements from a hyperloop object that are identical. Since the result in each run can be a list itself, only specific list elements can be used for comparison.

Usage

unique_elem(x, elem = NULL)

Arguments

Value

A reduced hyperloop object

Examples

x <- rnorm(100)
# 6 results: 3 different mu's, 2 var.equals
hl <- hyperloop(t.test, x=x, mu=list(-1, 0, 1), var.equal=list(TRUE, FALSE))
# reduction to 3 elements since var.equal does not play any role
length(unique_elem(hl))    
# reduction to 1 element since the mean of x always the same
length(unique_elem(hl, "estimate"))

Unique Maximum

Description

Checks if x has a unique maximum. The largest and the second largest value must have at least a distance of tol.

Usage

unique_max(x, tol = 0.001)

Arguments

Value

Logical

Examples

x <-runif(100)
unique_max(x)
unique_max(x, tol=0.1)

Vector to Matrix Conversion

Description

Converts a vector to a horizontal or vertical matrix and sets ⁠row-⁠ or colnames. If rownames or colnames are given, then existing row names or column names are overwritten.

Usage

vec2mat(x, colnames = NULL, rownames = NULL, horizontal = TRUE)

to_mat(x, colnames = NULL, rownames = NULL, horizontal = TRUE)

Arguments

Value

A matrix

Examples

x <- runif(5)
vec2mat(x)
vec2mat(x, horizontal=FALSE)