Description Usage Arguments Details Value Author(s) See Also
These functions are used internally by package distr.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69  .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 = 1e7)
.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(...)

x 
a (numeric) vector, or (in case of 
y 
a (numeric) vector 
f 
a function in one (numeric) argument 
lattice 
a lattice (of class 
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 rowwise 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 
stand 
factor for a (Lebesgue) density to integrate to 1 
sign 
the sign of the second operand — for multiplication at the moment 
correct 
unevaluated Rcode to correct for rightcontinuity (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 RCode —gives how the result of a call to

Cont 
logical: 
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 
dx 
numeric: vector of cellprobabilities for the (discretized) distribution 
myPf 
function with args 
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 
topat 
a (vector of) replacement(s) for matched pattern in

gaps,gaps1,gaps2 
matrices 
support 
support vector of a univariate discrete distribution 
prob 
probability vector for a univariate discrete distribution 
mixDistr 
an object of class 
mixCoeff 
an object of class 
pnew 
a function 
withStand 
logical; if 
supp 
NULL or 
p,pfun 
slot 
d 
slot 
q,qfun 
slot 
xx 
a given grid of xvalues for functions 
ql,qu 
lower and upper 
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 
Sim 
logical; slot 
list0 
list, the elements of which are to be copied to a new list using recycling if necessary 
len 
length of the list to be filled 
lower 
lower truncation point 
upper 
upper truncation point 
leftright 
character; for slot 
n1 
integer argument for 
n2 
integer argument for 
x1 
width argument for 
x2 
width argument for 
dots 
the unevaluated 
element 
the name of the item in the unevaluated 
... 
arguments passed through to other functions 
.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 gridvalues
.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<c<b
.
.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
onesided truncation, using (for slot r
) Peter Dalgaard's clever
logtricks as indicated in
http://r.789695.n4.nabble.com/helponsamplingfromthetruncatednormalgammadistributiononthefarendprobabilityisverylowtd868119.html#a868120.
.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.
.is.vector.lattice 

.is.consistent 

.notwithLArg 

.make.lattice.es.vector 
an object of class 
.inArgs 

.isIn, .isEqual,.isEqual01 
vector of 
.fm,.fM, .fM2 
a 
.plusm,.multm 
an object of class 
.getObjName 

.discretizeP 

.makeDd,.makePd, .makeQd 
a function with args

.makeD,.makeDNew 
a function with args 
.makeP,.makePNew 
a function with args 
.makeQ,.makeQNew 
a function with args 
.isInteger,.isNatural,.isNatural0 

.mergegaps,.mergegaps2 
a 
.pmixfun 
slot 
.dmixfun 
slot 
.qmixfun 
slot 
.rmixfun 
slot 
.deldmixfun 
a possibly modified argument 
.loupmixfun 
a list of four components: 
.ULC.cast 
an object of class 
.expm.d,.logm.d 
an object of class 
.expm.c,.logm.c 
an object of class 
.P2D 
a density 
.P2Q 
a quantile function 
.D2P, .Q2P 
a cdf 
.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. 
.List 
a list. 
.fillList 
a list. 
.trunc.up,.trunc.low 
a list with elements 
.DistrCollapse 
upon a suggestion by Jacob van Etten,
[email protected]: help function to collapse the support
points of a discrete distributions if they are too close to each other;
here argument 
.EuclidAlgo 
returns the greatest common divisor (an integer). 
.getCommonWidth 
returns the smallest common lattice width (a numeric). 
.convDiscrDiscr 
returns the convolution of two discrete distributions. 
.inWithTol 
returns a logical vector of same lenght as 
.panel.mingle 
used for mingling arguments 
devNew 
returns the return value of the device opened,
usually invisible 
Peter Ruckdeschel [email protected], Matthias Kohl [email protected]
AbscontDistribution
,
DiscreteDistribution
,
LatticeDistribution
,
RtoDPQ
,
RtoDPQ.d
,
convpow
,
operators
,
plotmethods
dev.new
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.