LatticeDistribution-class {distr}R Documentation

Class "LatticeDistribution"

Description

The LatticeDistribution-class is the mother-class of the classes Binom, Dirac, Geom, Hyper, Nbinom and Poisson. It formalizes a distribution on a regular affine linear lattice.

Usage

  LatticeDistribution(DiscreteDistribution)
  LatticeDistribution(lattice, DiscreteDistribution)
  LatticeDistribution(lattice, supp, prob, .withArith, .withSim, check = FALSE)
  LatticeDistribution(lattice, supp, prob)
  LatticeDistribution(supp)

Arguments

DiscreteDistribution an object of class DiscreteDistribution or AffLinDiscreteDistribution to be coerced to LatticeDistribution or AffLinLatticeDistribution, respectively
lattice lattice (of class Lattice) which determines the support of the discrete distribution.
supp numeric vector which forms the support of the discrete distribution.
prob vector of probability weights for the elements of supp.
.withArith normally not set by the user, but if determining the entries supp, prob distributional arithmetics was involved, you may set this to TRUE.
.withSim normally not set by the user, but if determining the entries supp, prob simulations were involved, you may set this to TRUE.
check logical: if TRUE, LatticeDistribution() throws an error if argument lattice and other arguments are inconsistent or if there is no way to automatically generate a lattice argument. If check == FALSE, LatticeDistribution() returns an object of DiscreteDistribution, ignoring argument lattice

Details

For the generating function LatticeDistribution(), the arguments are processed in the following order:
Arguments .withSim and .withArith are used in any case.
If there is an argument DiscreteDistribution (of the respective class), all its slots (except for .withSim and .withArith) will be used for the filling the slots of the object of class LatticeDistribution()/AffLinLatticeDistribution(). If in addition, there is an argument lattice of class Lattice, it will be checked for consistency with argument DiscreteDistribution and if oK will be used for slot lattice of the object of class LatticeDistribution()/AffLinLatticeDistribution(). In case there is no lattice argument, slot lattice will be constructed from slot support from argument DiscreteDistribution.
If there is no argument DiscreteDistribution, but there are arguments supp and lattice (the latter of class Lattice) then these are checked for consistency and if oK, generating function DiscreteDistribution() is called with arguments supp, prob, .withArith, and .withSim to produce an object of class DiscreteDistribution the slots of which will be used for the filling the slots of the object of class LatticeDistribution()/AffLinLatticeDistribution(). If in this case, argument prob is not given explicitely, all elements in supp are equally weighted.
If there is no argument DiscreteDistribution, but there is an argument lattice of class Lattice (but no argument slot) then if Length(lattice) is finite, a corresponding support vector supp is generated from argument lattice and generating function DiscreteDistribution() is called with arguments supp, prob, .withArith, and .withSim to produce an object of class DiscreteDistribution the slots of which will be used for the filling the slots of the object of class LatticeDistribution(). If in the same situation Length(lattice) is not finite, a finite length for the support vector is extracted from argument prob and after generating supp one procedes as in the finite Length(lattice) case.
If there is no argument DiscreteDistribution and no argument lattice of class Lattice but an argument supp then it will be checked if supp makes for a lattice, and if so, DiscreteDistribution() is called with arguments supp, prob, .withArith, and .withSim to produce an object of class DiscreteDistribution the slots of which will be used for the filling the slots of the object of class LatticeDistribution(). The corresponding lattice-slot will be filled with information from argument supp.
The price for this flexibility of arguments, LatticeDistribution() may be called with, is that you should call LatticeDistribution() with named arguments only.
Note that internally we suppress lattice points from the support where the probability is 0.

Objects from the Class

The usual way to generate objects of class LatticeDistribution is to call the generating function LatticeDistribution() (see details).
Somewhat more flexible, but also proner to inconsistencies is a call to new("LatticeDistribution"), where you may explicitly specify random number generator, (counting) density, cumulative distribution and quantile functions. For conveniance, in this call to new("LatticeDistribution"), an additional possibility is to only specify the random number generator. The function RtoDPQ.d then approximates the three remaining slots d, p and q by random sampling.

Slots

img:
Object of class "Reals": the space of the image of this distribution which has dimension 1 and the name "Real Space"
param:
Object of class "Parameter": the parameter of this distribution, having only the slot name "Parameter of a discrete distribution"
r:
Object of class "function": generates random numbers
d:
Object of class "function": (counting) density/probability function
p:
Object of class "function": cumulative distribution function
q:
Object of class "function": quantile function
.withArith:
logical: used internally to issue warnings as to interpretation of arithmetics
.withSim:
logical: used internally to issue warnings as to accuracy
support:
Object of class "numeric": a (sorted) vector containing the support of the discrete density function
lattice:
Object of class "Lattice": the lattice generating the support.

Extends

Class "UnivariateDistribution", directly.
Class "Distribution", by class "UnivariateDistribution".

Methods

initialize
signature(.Object = "LatticeDistribution"): initialize method
-
signature(e1 = "LatticeDistribution"): application of `-' to this lattice distribution
*
signature(e1 = "LatticeDistribution", e2 = "numeric"): multiplication of this lattice distribution by an object of class `numeric'
/
signature(e1 = "LatticeDistribution", e2 = "numeric"): division of this lattice distribution by an object of class `numeric'
+
signature(e1 = "LatticeDistribution", e2 = "numeric"): addition of this lattice distribution to an object of class `numeric'
-
signature(e1 = "LatticeDistribution", e2 = "numeric"): subtraction of an object of class `numeric' from this lattice distribution
*
signature(e1 = "numeric", e2 = "LatticeDistribution"): multiplication of this lattice distribution by an object of class `numeric'
+
signature(e1 = "numeric", e2 = "LatticeDistribution"): addition of this lattice distribution to an object of class `numeric'
-
signature(e1 = "numeric", e2 = "LatticeDistribution"): subtraction of this lattice distribution from an object of class `numeric'
+
signature(e1 = "LatticeDistribution", e2 = "LatticeDistribution"): Convolution of two lattice distributions. Slots p, d and q are approximated by grids.
-
signature(e1 = "LatticeDistribution", e2 = "LatticeDistribution"): Convolution of two lattice distributions. The slots p, d and q are approximated by grids.
lattice
accessor method to the corresponding slot.
coerce
signature(from = "LatticeDistribution", to = "DiscreteDistribution"): coerces an object from "LatticeDistribution" to "DiscreteDistribution" thereby cancelling out support points with probability 0.

Internal subclass "AffLinLatticeDistribution"

To enhance accuracy of several functionals on distributions, mainly from package distrEx, there is an internally used (but exported) subclass "AffLinLatticeDistribution" which has extra slots a, b (both of class "numeric"), and X0 (of class "LatticeDistribution"), to capture the fact that the object has the same distribution as a * X0 + b. This is the class of the return value of methods

There is also an explicit coerce-method from class "AffLinLatticeDistribution" to class "AffLinDoscreteDistribution" which cancels out support points with probability 0.

Note

Working with a computer, we use a finite interval as support which carries at least mass 1-getdistrOption("TruncQuantile").

Author(s)

Peter Ruckdeschel Peter.Ruckdeschel@uni-bayreuth.de

See Also

Parameter-class Lattice-class UnivariateDistribution-class DiscreteDistribution-class Binom-class Dirac-class Geom-class Hyper-class Nbinom-class Pois-class AbscontDistribution-class Reals-class RtoDPQ.d

Examples

B <- Binom(prob = 0.1,size = 10) # B is a Binomial distribution w/ prob=0.1 and size=10.
P <- Pois(lambda = 1) # P is a Poisson distribution with lambda = 1.
D1 <- B+1 # a new Lattice distributions with exact slots d, p, q
D2 <- D1*3 # a new Lattice distributions with exact slots d, p, q
D3 <- B+P # a new Lattice distributions with approximated slots d, p, q
D4 <- D1+P # a new Lattice distributions with approximated slots d, p, q
support(D4) # the (approximated) support of this distribution is 1, 2, ..., 21
r(D4)(1) # one random number generated from this distribution, e.g. 4
d(D4)(1) # The (approximated) density for x=1 is 0.1282716.
p(D4)(1) # The (approximated) probability that x<=1 is 0.1282716.
q(D4)(.5) # The (approximated) 50 percent quantile is 3.

[Package distr version 1.9 Index]