Geometric Random Variable:
It can be shown that a Geometric random variable can be
simulated using the following argument (int(ln(u)/ln(1-p)) + 1)
where **u** is a uniform(0,1) random variable and **p** is the probability
of observing a success (Simulation by Ross, 2003). In this example we are going to generate
a Geometric
random variable with 1000 observations with probability of success **p** = 0.25.

clear set obs 1000 local p = .25 gen u = uniform( ) gen g = int(ln(u)/ln(1-`p')) + 1

Negative Binomial Random Variable as a sum of independent Geometric Random
Variables:
To generate a Negative Binomial random variable we make use
of the fact that a Negative Binomial random variable is sum of **r**
independent Geometric random variables, where **r** is the of trials required
to observe the r^{th} success and **p** is the probability of a success. In this
example, we are going to simulate **p** = 0.25 and let **r** = 4. Note
that unlike in the geometric case, the uniform(0,1) is defined within the **
foreach** argument so that the r trials are independent.

clear set obs 1000 local r = 4 local p = .25 foreach var of newlist nb1-nb`r' { gen `var' = int(ln(uniform( ))/ln(1-`p')) + 1 } egen nb = rsum(nb1-nb`r') drop nb1-nb`r'

Poisson and Zero-Inflated Poisson Random Variable:
We can simulate a Poisson and Zero-Inflated Poisson random variable
by recoding a uniform(0,1) random variable in terms of the cumulative
distribution. What allows us to simulate both types of variables in the same
code fragment is when we specify **p0**–the percent of zeros not explained
by a Poisson distribution–to be 0, the Zero-Inflated Poisson reduces to the
traditional Poisson distribution. The **while** loop continues until the
cumulative probability exceeds 0.99999 (a problem may exist if a value from the
uniform random variable is greater than 0.99999). What is required for this code
fragment is the specification of the Poisson parameter **lambda** and **p0.**

We need to note that the program was stable for values of
lambda less than 100. We recommend checking that **x** was recoded for all
values before proceeding.

clear set obs 1000 gen x = uniform( ) gen u = x local lambda = 10 local p0 = .40 local cp=0 local n =0 while `cp'<=.99999 { local p = `p0'*(`n'==0) + (1-`p0')*exp(-1*`lambda')*(`lambda'^`n')/exp(lnfactorial(`n')) local cp= `cp'+`p' local pcp = `cp'-`p' quietly recode x (`pcp'/`cp' = `n') local n = `n' + 1 }

Negative Binomial and Zero-Inflated Negative Binomial Random Variable that allows for over dispersion.
The hallmark of the Poisson distribution is that the mean is
equal to the variance. Many times that assumption is not satisfied and the
variance is greater than the mean. To account for the over-dispersion, we can
use a Negative
Binomial as a Gamma mixture of Poisson random variable that accounts for
over-dispersion by adding a parameter alpha. Like the prior code fragment,
we can simulate both types of variables within the same code fragment (the prior
code was more stable when we specified extreme values of **lambda** and **p0**,
this one is not. We recommend using conservative values of the parameter and
checking that **x** was recoded for all values). When alpha is equal to zero, we end up with a
Poisson random variable (this
program blows up if you set alpha = 0, instead we recommend setting alpha =0.01).
The code fragment requires the specification of the **mean, p0** and **alpha**. The density
formula of the negative binomial distribution was taken from Regression Analysis
of Count Data by Cameron and Trivedi, formula (4.14).

clear set obs 1000 gen x = uniform( ) gen u = x local mean = 20 local alpha = .1 local p0 = .20 local a = 1/`alpha' local cp=0 local n =0 while `cp'<.99999 { local p = `p0'*(`n'==0) + (1-`p0')*(exp(lngamma(`n'+`a')) / (exp(lngamma(`a'))*(exp(lnfactorial(`n')))))*((`a'/(`a'+`mean'))^`a') /// *((`mean'/(`mean'+`a'))^`n') local cp= `cp'+`p' local pcp = `cp'-`p' quietly recode x (`pcp'/`cp' = `n') local n = `n' + 1 }