.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(...)
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 objectslogical
(length 1)logical
(length 1)logical
(length 1)Lattice
logical
(length 1)logical
numeric
of length 1DiscreteDistribution
or
AbscontDistribution
according to argument DClass
character
numeric
--- the probabilities for the grid-valuesx, 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 orderedp
for a mixing distribution, i.e. a function
function(q, lower.tail = TRUE, log.p = FALSE)
, which
is the cdf of the distributiond
for a mixing distribution, i.e. a function
function(x, log = FALSE)
, which
is the density of the distributionq
for a mixing distribution, i.e. a function
function(p, lower.tail = TRUE, log.p = FALSE)
, which
is the quantile function of the distributionr
for a mixing distribution, i.e. a function
function(n)
generating r.v.'s according to the distributionqL
, 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."DiscreteDistribution"
."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'}.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.
.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.
AbscontDistribution
,
DiscreteDistribution
,
LatticeDistribution
,
RtoDPQ
,
RtoDPQ.d
,
convpow
,
operators
,
plot-methods
dev.new