internals_for_distr

From distr v2.0.2 by Peter Ruckdeschel

Internal functions of package distr

These functions are used internally by package distr.

Keywords: internal

Usage

.is.vector.lattice(x)
.is.consistent(lattice, support, eq.space = TRUE)
.make.lattice.es.vector(x)
.inArgs(arg, fct)
.isEqual(p0, p1, tol = min( getdistrOption("TruncQuantile")/2,
                                          .Machine$double.eps^.7))
.isEqual01(x)
.isIn(p0, pmat, tol = min( getdistrOption("TruncQuantile")/2,
                                          .Machine$double.eps^.7
                                          ))
.isInteger(x, tol = .Machine$double.eps)
.isNatural(x, tol = .Machine$double.eps)
.isNatural0(x, tol = .Machine$double.eps)
.setEqual(x, y, tol = 1e-7)
.presubs(inp, frompat, topat)
.makeD(object, argList,  stand = NULL, fac = NULL)
.makeP(object, argList,  sign = TRUE, correct = NULL, fac =
                 NULL, fac2 = NULL)
.makeQ(object, lastCall, sign = TRUE, Cont = TRUE)
.plusm(e1, e2, Dclass = "DiscreteDistribution")
.multm(e1, e2, Dclass = "DiscreteDistribution")
.notwithLArg(D)
.getObjName(i = 1)
.discretizeP(D, lower, upper, h)
.fm(x,f)
.fM(x,f)
.fM2(x,f)
.makeDd(x,y, yleft, yright)
.makePd(x,y, yleft, yright)
.makeQd(x,y, yleft, yright)
.makeQc(x,y, yleft, yright)
.makeDNew(x, dx, h = NULL, Cont = TRUE, standM = "sum")
.makePNew(x, dx, h = NULL, notwithLLarg = FALSE,
                      Cont = TRUE, myPf = NULL, pxl = NULL, pxu = NULL)
.makeQNew(x, px.l, px.u, notwithLLarg = FALSE, yL , yR, Cont = TRUE)
.mergegaps(gaps, support)
.mergegaps2(gaps1, gaps2)
.pmixfun(mixDistr, mixCoeff)
.dmixfun(mixDistr, mixCoeff, withStand = FALSE, supp = NULL)
.rmixfun(mixDistr, mixCoeff)
.qmixfun(mixDistr, mixCoeff, Cont = TRUE, pnew)
.loupmixfun(mixDistr)
.expm.d(e1)
.expm.c(e1)
.logm.d(e1)
.logm.c(e1)
.P2D (p, xx, ql, qu, ngrid = getdistrOption("DefaultNrGridPoints"))
.P2Q (p, xx, ql,qu, ngrid = getdistrOption("DefaultNrGridPoints"), 
                qL = -Inf, qU = Inf)
.D2P (d, xx, ql, qu,  ngrid = getdistrOption("DefaultNrGridPoints"))
.Q2P (q, ngrid = getdistrOption("DefaultNrGridPoints"))
.csimpsum(fx)
.primefun(f,x, nm = NULL)
.IssueWarn(Arith,Sim)
devNew(...)

Arguments

x: a (numeric) vector
y: a (numeric) vector
f: a function in one (numeric) argument
lattice: a lattice (of class Lattice)
support: a support vector
eq.space: logical: shall we check for the support to be equally spaced?
arg: a formal argument as character
fct: a function
p0,p1: (numeric) vectors
pmat: (matrix) a matrix with two columns where row-wise the left column is smaller than the right one
tol: an error tolerance (numeric)
e1: a distribution object
e2: a numeric
object: a distribution object
argList: an (unevaluated) list of arguments passed to m(object) where m is in d,p,q
stand: factor for a (Lebesgue) density to integrate to 1
sign: the sign of the second operand --- for multiplication at the moment
correct: unevaluated R-code to correct for right-continuity (for multiplication with negative numerics at the moment)
fac: factor to be multiplied with the return value
fac2: factor to be added to the return value
lastCall: unevaluated R-Code ---gives how the result of a call to q(e1) is further transformed
Cont: logical: TRUE if object is continuous
DClass: character: name of distribution class
D: a distribution object
i: an integer
yleft, yright: extrapolation value beyond left/right endpoint of grid
h: numeric: grid width
standM: standardization method --- summation or integration
notwithLLarg: logical --- can we use log.p, lower.tail arguments for p,q-methods of first operand?
dx: numeric: vector of cell-probabilities for the (discretized) distribution
myPf: function with args x,y, yleft, yright (as approxfun): if given: replaces approxfun as interpolation method for continuos distributions
pxl,pxu: numeric: if given vector of (lower/upper) cumulative probabilities
yL, yR: argmin / argmax of p()-method
inp: either a language object or a character vector
frompat: vector of character strings containing regular expressions (or character string for fixed = TRUE) to be matched in the given character vector. Coerced by as.character to a character string if pos
topat: a (vector of) replacement(s) for matched pattern in .presubs. Coerced to character if possible. For fixed = FALSE this can include backreferences "\1"' to "\9" to
gaps,gaps1,gaps2: matrices m with two columns, such that t(m), interpreted as vector, is ordered
support: support vector of a univariate discrete distribution
mixDistr: an object of class UnivarDistrList
mixCoeff: an object of class numeric; a probability vector
pnew: a function function(q, lower.tail = TRUE, log.p = FALSE realizing slot p in a distribution object.
withStand: logical; if TRUE a standardization is made such that the sum of the values of the result evaluated at argument supp is 1
supp: NULL or numeric; if withStand is TRUE used to standardize such that the result is a probability density.
p: slot p of an object of class "AbscontDistribution"
d: slot d of an object of class "AbscontDistribution"
q: slot q of an object of class "AbscontDistribution"
xx: a given grid of x-values for functions p, d to be evaluated at
ql,qu: lower and upper getdistrOption("TruncQuantile")-quantile of the distribution; also, if argument xx is missing, left and right endpoint of a regular grid of ngrid gridpoints to be used in place of xx.
qL,qU: argmin / argmax of p()-method
ngrid: number of gridpoints
fx: a vector of function evaluations multiplied by the gridwidth
f: a vector of function evaluations
nm: an optional right asymptotic value
Arith: logical; slot .withArith of a distribution object, or logically-``any'' of these slots in a collection of such objects
Sim: logical; slot .withSim of a distribution object, or logically-``any'' of these slots in a collection of such objects
...: arguments passed through to other functions

Details

.is.vector.lattice checks whether a given vector x is equally spaced. .is.consistent checks whether a given support vector support is consistent to a given lattice lattice --- with or without checking if support is equally spaced. .make.lattice.es.vector makes an object of class Lattice out of a given (equally spaced) vector x. .inArgs checks whether an argument arg is a formal argument of fct --- not vectorized. .isEqual checks whether p0 and p1 are equal to given tolerance. .isIn checks whether p0 lies in any of the intervals given by matrix pmat to given tolerance. .isEqual01(x) checks whether x is 0 or 1 to given tolerance. .setEqual sets all elements of x which are equal to some element of y up to tolerance tol, to exactly the respective element of y. .notwithLArg checks whether object D was generated by simulations or if its slots p,q do not have lower.tail arguments. .getObjName returns the name of the object in the ith operand. .discretizeP discretizes D to a grid of probabilities from lower to upper with width h. .fm, .fM return the smallest / biggest value in (0,1) such that f(x) is finite; .fM2 is a variant of .fM using a lower.tail = FALSE argument. .makeD, .makeP, .makeQ generate slots p,d,q for binary operations e1 /op/ e2 for a distribution object e1 and a numeric e2 ---for the moment only /op/'s +,-,*,/ are implemented. .plusm, .multm more specifically use .makeD, .makeP, .makeQ to generate slots p,d,q for +, *, respectively. .makeDd, .makePd, .makeQd provide discrete analogues to approxfun for interpolation at non grid-values .makeQc is an analogue to makeQd for absolutely continuous distributions using approxfun. .makeDNew generates slot d for a new distribution object. In case of a discrete distribution it produces a step function with stepfun (using .makeDd) and standardizes to 1 by summation. In case of a continuous distribution it produces a density function with approxfun and standardizes to 1 by integration if the latter fails, it uses a trapezoid rule / summation for this purpose. .makePNew generates slot p for a new distribution object. In case of a discrete distribution it produces a step function from cumsum applied to dx ---or from pxl if this is given, with stepfun (using .makePd). In case of a continuous distribution it produces a cdf with approxfun. In case of RtoDPQ, approxfun is replaced by myPf which calls ecdf directly. .makeQNew generates slot q for a new distribution object. In case of a discrete distribution it produces a step function (using .makeQd). Special care is taken for left continuity... In case of a continuous distribution it produces a quantile function with approxfun. .isInteger, .isNatural, and .isNatural0 test for each coordinate of argument x whether it is integer [natural / natural or 0] or not. .mergegaps modifies the gaps matrix of an a.c. distribution according to the support slot of a discrete distribution; if necessary, a gap interval [a,b] is split into [a,c],[c,b] if a. .mergegaps2 merges two gap matrices of two a.c. distributions X1 and X2 such that in the intervals of the resulting gap matrix, neither X1 nor X2 carries mass. .pmixfun, .dmixfun, .rmixfun, and .qmixfun fill the slots p, d, r, and q of a corresponding mixing distribution according to the arguments in mixDistr, mixCoeff. .loupmixfun finds commun lower and upper bounds for the support of the mixing distribution. .expm.d,.expm.c for discrete, resp. a.c. argument e1 fill the slots p, d, r, and q of the transformation exp(e1) exactly. .logm.d,.logm.c for discrete, resp. a.c. argument e1 fill the slots p, d, r, and q of the transformation log(e1) exactly. For objects of class AbscontDistribution, .P2D and .P2Q reconstruct function slots d resp. q from function slot p by means of function D1ss from package sfsmisc; and of function .makeQNew, respectively. The other way round, .D2P and .Q2P reconstruct function slot p from from function slots d resp. q by means of function .makePNew and explicite numeric inversion, respectively. .csimpsum is used internally in .makePNew to produce a primitive function out of function evaluations by means of vectorized Simpson quadrature method, returning already the function values of the prime function on a grid; it is to mimick the behaviour of cumsum. .primefun is similar but more flexible and produces the prime function as a function. devNew opens a new device. This function is for back compatibility with R versions < 2.8.0.

Value

.is.vector.latticelogical (length 1)
.is.consistentlogical (length 1)
.notwithLArglogical (length 1)
.make.lattice.es.vectoran object of class Lattice
.inArgslogical (length 1)
.isIn, .isEqual,.isEqual01vector of logical
.fm,.fM, .fM2a numeric of length 1
.plusm,.multman object of class DiscreteDistribution or AbscontDistribution according to argument DClass
.getObjNamecharacter
.discretizePnumeric --- the probabilities for the grid-values
.makeDd,.makePd, .makeQda function with args x, y, yleft, yright
.makeD,.makeDNewa function with args x, log = FALSE
.makeP,.makePNewa function with args q, lower.tail = TRUE, log.p = FALSE
.makeQ,.makeQNewa function with args p, lower.tail = TRUE, log.p = FALSE
.isInteger,.isNatural,.isNatural0logical (same length as argument x)
.mergegaps,.mergegaps2a gaps-matrix, i.e.; a matrix m with two columns, such that t(m), interpreted as vector, is ordered
.pmixfunslot p for a mixing distribution, i.e. a function function(q, lower.tail = TRUE, log.p = FALSE), which is the cdf of the distribution
.dmixfunslot d for a mixing distribution, i.e. a function function(x, log = FALSE), which is the density of the distribution
.qmixfunslot q for a mixing distribution, i.e. a function function(p, lower.tail = TRUE, log.p = FALSE), which is the quantile function of the distribution
.rmixfunslot r for a mixing distribution, i.e. a function function(n) generating r.v.'s according to the distribution
.loupmixfuna list of four components: qL, the minimal value of q(x)(0), ql, the minimal value of q(x)(getdistrOption("TruncQuantile")), qU, the maximal value of q(x)(1), qu, the maximal value of q(x)(getdistrOption("TruncQuantile"), lower.tail = FALSE), x running through the members of mixDistr in each case.
.expm.d,.logm.dan object of class "DiscreteDistribution".
.expm.c,.logm.can object of class "AbscontDistribution".
.P2D{a density d as function function(x, log = FALSE)} .P2Q{a quantile function q as function function(p, lower.tail = TRUE, log.p = FALSE)} .D2P, .Q2P{a cdf p as function function(q, lower.tail = TRUE, log.p = FALSE)} .csimpsum{a vector of evaluations of the prime function at the grid points} .primefun{the prime function as a function} .IssueWarn{a list with two warnings to be issued each of which may be empty} devNew{returns the return value of the device opened, usually invisible 'NULL'}

concept

utilities

Community examples

Looks like there are no examples yet.