.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)
.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"))
devNew(...)
.ULC.cast
) an object of class "AcDcLcDistribution"
Lattice
)m(object)
where m
is in d,p,q
q(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 pos.presubs
.
Coerced to character if possible. For fixed = FALSE
this
can include backreferences "\1"
to "\9"
to
m
with two columns,
such that t(m)
, interpreted as vector, is orderedUnivarDistrList
numeric
; 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
logical
(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
.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 i
th 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.
.fillList
fills a new list with the elements of a given list list0
until length len
is reached using recycling 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.
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