.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)
.consolidategaps(gaps)
.pmixfun(mixDistr, mixCoeff, leftright = "right")
.dmixfun(mixDistr, mixCoeff, withStand = FALSE, supp = NULL)
.rmixfun(mixDistr, mixCoeff)
.qmixfun(mixDistr, mixCoeff, Cont = TRUE, pnew, gaps = NULL, leftright = "left")
.del0dmixfun(mixDistr)
.loupmixfun(mixDistr)
.ULC.cast(x)
.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)
.List(list0)
.fillList(list0, len=length(list0))
.trunc.up(object, upper)
.trunc.low(object, lower)
.modifyqgaps(pfun, qfun, gaps, leftright = "left")
.DistrCollapse(support, prob, eps = getdistrOption("DistrResolution"))
.EuclidAlgo(n1,n2)
.getCommonWidth(x1,x2, tol=.Machine$double.eps)
.convDiscrDiscr(e1,e2)
.inWithTol(x,y,tol=.Machine$double.eps)
.panel.mingle(dots,element)
devNew(...).ULC.cast) an object of class "AcDcLcDistribution"Lattice)m(object)
where m is in d,p,qq(e1) is further transformedTRUE if object is continuouslog.p, lower.tail
arguments for p,q-methods of first operand?x,y, yleft, yright
(as approxfun):
if given: replaces approxfun as interpolation method for
continuos distributionsfixed = TRUE) to be matched in the
given character vector. Coerced by as.character to a
character string if possible; (as argument pattern in
gsub --- but possibly of length >1)..presubs.
Coerced to character if possible. For fixed = FALSE this
can include backreferences "\1" to "\9" to
parenthesized subexpressions of pattern. For
perl = TRUE only, it can
also contain "\U" or "\L" to convert the rest of the
replacement to upper or lower case; (as argument replacement
in gsub--- but possibly of length >1).m with two columns,
such that t(m), interpreted as vector, is orderedUnivarDistrListnumeric; a probability vectorfunction(q, lower.tail = TRUE, log.p = FALSE
realizing slot p in a distribution object.TRUE a standardization is made such
that the sum of the values of the result evaluated at argument supp is 1numeric; if withStand is TRUE used
to standardize such that the result is a probability density.p of an object of class "AbscontDistribution"d of an object of class "AbscontDistribution"q of an object of class "AbscontDistribution"p, d to be
evaluated atgetdistrOption("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..withArith of a distribution object,
or logically-``any'' of these slots in a collection of such objects.withSim of a distribution object,
or logically-``any'' of these slots in a collection of such objectsq: if partially matched to "right"
function will return the right continuous version, else
the left continuous version; for slot p: if partially
matched to "left" the left continuous version, else
the right continuous version;.EuclidAlgo.EuclidAlgo.getCommonWidth.getCommonWidth... argument... argumentlogical (length 1).logical (length 1).logical (length 1).Lattice.logical (length 1).logical.numeric of length 1.DiscreteDistribution or
AbscontDistribution according to argument DClass.character.numeric --- the probabilities for the grid-values.x, y, yleft, yright.x, log = FALSE.q, lower.tail = TRUE,
log.p = FALSE.p, lower.tail = TRUE,
log.p = FALSE.logical (same length as argument x).gaps-matrix, i.e.; a matrix m with two columns,
such that t(m), interpreted as vector, is ordered.p for a mixing distribution, i.e. a function
function(q, lower.tail = TRUE, log.p = FALSE), which
is the cdf of the distribution.d for a mixing distribution, i.e. a function
function(x, log = FALSE), which
is the density of the distribution.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.r for a mixing distribution, i.e. a function
function(n) generating r.v.'s according to the distribution.mixDistr.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."UnivarLebDecDistribution"."DiscreteDistribution"."AbscontDistribution".d as function function(x, log = FALSE).q as function function(p,
lower.tail = TRUE, log.p = FALSE)p as function function(q,
lower.tail = TRUE, log.p = FALSE).r,p,d,q (in this order).support is the (original; already sorted) support
and prob a corresponding probability vector of same length.
Criterium for collapsing: a distance smaller than argument
eps.
x for the
matches (up to tolerance) with vector y.panel.first,
panel.last; returns the evaluated argument element within dots,
if it is a symbol; else if it can be interpreted as a call, and if the top
call is list, it returns a list of the items of the call to list,
unevaluated, and otherwise the unchanged argument.NULL..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.
.consolidategaps consolidates a gap matrix, i.e. joins adjacent
gap intervals.
.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.
.del0dmixfun sets (if slot d.ac is not NULL) the return
value of slot function d.ac of mixDistr
for argument 0 to 0.
.ULC.cast coerces an object of class "AcDcLcDistribution" to
class "UnivarLebDecDistribution", using simplifyD.
.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.
.List checks if argument already is a list, and if so leaves it as
it is, otherwise casts it to a list by a call to list.
.fillList fills a new list with the elements of a given list list0
until length len is reached using recycling if necessary.
Argument list0 is cast to list by a call
to .List if necessary.
.trunc.up, .trunc.low provide common routines for
classes DiscreteDistribution and AbscontDistribution for
one-sided truncation, using (for slot r) Peter Dalgaard's clever
log-tricks as indicated in
http://article.gmane.org/gmane.comp.lang.r.general/126112.
.modifyqgaps modifies slot q for objects of class
AbscontDistribution in the presence of gaps, i.e.; if slot
gaps is not NULL. If argument leftright does not
partially match "right" (default) returns the left continuous
version of the quantile function, else the right continuous one.
.EuclidAlgo computes the greatest common divisor of two integers by
means of the Euclidean algorithm.
.getCommonWidth for two lattices with widths x1 and x2
computes the smallest common lattice width for convolution.
.convDiscrDiscr computes the convolution of two discrete distributions by
brute force.
.inWithTol works like %in% but with a given tolerance.
.panel.mingle is used for mingling arguments panel.first,
panel.last in a plot; it returns the evaluated argument element
within dots, if it is a symbol; else if it can be interpreted as a call, and if
the top call is list, it returns a list of the items of the call to list,
unevaluated, and otherwise the unchanged argument.
devNew opens a new device. This function is for back compatibility
with R versions < 2.8.0.
AbscontDistribution,
DiscreteDistribution,
LatticeDistribution,
RtoDPQ,
RtoDPQ.d,
convpow,
operators,
plot-methods
dev.new