在 R 中手动模拟泊松过程

Question

The following problem tells us to generate a Poisson process step by step from ρ (inter-arrival time), and τ (arrival time).

One of the theoretical results presented in the lectures gives the following direct method for simulating Poisson process:

• Let τ ₀ = 0.
• Generate iid exponential random variables ρ1, ρ2, . . ..
• Let τ _n = ρ ₁ +. . . + ρ _n for n = 1, 2, . . . .
• For each k = 0, 1, . . ., let N _t = k for τ _k ≤ t < τ _k+1 .

1. Using this method, generate a realization of a Poisson process (N _t ) _t with λ = 0.5 on the interval [0, 20].
2. Generate 10000 realizations of a Poisson process (N _t ) _t with λ = 0.5 and use your results to estimate E(N _t ) and Var(N _t ). Compare the estimates with the theoretical values.

My attempted solution:

First, I have generated the values of ρ using rexp() function in R.

rhos <-function(lambda, max1)
{
    vec <- vector()

    for (i in 1:max1) 
    {
        vec[i] <- rexp(0.5)
    }

    return (vec)
}

then, I created τ s by progressive summing of ρ s.

taos <- function(lambda, max)
{
    rho_vec <- rhos(lambda, max)
    #print(rho_vec)

    vec <- vector()
    vec[1] <- 0
    sum <- 0
    for(i in 2:max)
    {
        sum <- sum + rho_vec[i]
        vec[i] <- sum
    }

    return (vec)
}

The following function is for finding the value of N _t =k when the value of k is given. Say, it is 7 , etc.

Ntk <- function(lambda, max, k)
{
    tao_vec <- taos(lambda, max)
    val <- max(tao_vec[tao_vec < k])
}

y <- taos(0.5, 20)
x <- seq(0, 20-1, by=1)

plot(x,y, type="s")

Output:

As you can see, the plot of the Poisson process is blank rather than a staircase.

If I change rexp to exp , I get the following output:

.. which is a staircase function but all steps are equal.

Why is my source code not producing the expected output?

Answer 1

It looks like you're using max1 to indicate how many times to sample the exponential distribution in your rhos function. I would recommend something like this:

rhosGen <- function(lambda, maxTime){
  rhos <- NULL
  i <- 1
  while(sum(rhos) < maxTime){
    samp <- rexp(n = 1, rate = lambda)
    rhos[i] <- samp
    i <- i+1
  }
  return(head(rhos, -1))
}

This will continue to sample from the exponential until the sum of these holding times is larger than the length of the given interval. head the removes the last sample so that all of the events that we keep track of definitely occur in our time interval of interest. From here you have to generate the taos by summing the previous holding times (rhos):

taosGen <- function(lambda, maxTime){
  rhos <- rhosGen(lambda, maxTime)
  taos <- NULL
  cumSum <- 0
  for(i in 1:length(rhos)){
    taos[i] <- sum(rhos[1:i])
  }
  return(taos)
}

Now that you have the taos we know at what time each event in the time interval (0,maxTime) occurs. This leads us to generating the associated Poisson Process by finding the value of the Nt for each t in the time interval:

ppGen <- function(lambda, maxTime){
  taos <- taosGen(lambda, maxTime)
  pp <- NULL
  for(i in 1:maxTime){
    pp[i] <- sum(taos <= i)
  }
  return(pp)
}

This generates the value of the Poisson Process at each integer time in the interval. I suspect that part of your issue was trying to put the tao values on the y-axis instead of the count of events that had occurred already. The following code worked for me to produce a random looking stair case, similar to your example.

y <- ppGen(0.5, 20)
x <- seq(0, 20-1, by=1)

plot(x,y, type="s")

Answer 2

Here's another possible implementation. The idea is to generate a vector of wait times (tau), and plot that against the list of events we're waiting for (max1)

poi.process <- function(lambda,n){
  
  # initialize vector of total wait time for the arrival of each event:
  s<-numeric(n+1)
  # set S_0 = 0
  s[1] <-0
  # generate vector of iid Exp random variables:
  x <-replicate(n,rexp(1,lambda))
  # assign wait time to vector s in for loop:
  for (k in 1:n){
    
    s[k+1] <-sum(x[1:k])
    
  }
  # return vector of wait time
  return(s)
  
}

Plotting it using stepfun will get us something like this:

n<-20

lambda <-3

# simulate list of wait time:
s_list <-poi.process(lambda,n)

# plot function:
plot(stepfun(0:(n-1), s_list), 
     do.points = TRUE,
     pch = 16,
     col.points = "red",
     verticals = FALSE,
     main = 'Realization of a Poisson process with lambda = 3',
     xlab = 'Time of arrival',
     ylab = 'Number of arrivals')

Sample Poisson process: