这个R代码是什么意思？

Question

f <- function(x,q){ ## one step of the Newton iteration
  x-(pnorm(x)-q)/dnorm(x)
  }

x <- 0; #starting value
xj <- x # I don't know what is happening from this point onward! 
for (i in 1:10){
  x <- f(x,0.99);
  xj <- c(xj,x)
  }
print(xj)

Basically, here I am trying to compute the 0.99 quantile of the Normal Distribution using Newtons Algorithm, and apparently this is the solution. However, I don't follow what is happening from the step I have pointed out above. Could someone explain this to me in simple terms? What is happening in the for loop exactly? Mainly, what is going on in the xj <- c(xj,x) step? I'm completely new to programming and I would really appreciate the help!

Thanks!

Answer 1

You are running the function you defined as f 10 times, each time updating the value plugged into it (x) with the result of the previous run. The first time the function runs, the value of x is 0 , so the equation, 0-(pnorm(0)-0.99)/dnorm(0) gets computed as 1.228248 . This result then gets appended to the numeric vector, xj . The function f then runs a second time with this first result plugged in as x -- 1.228248-(pnorm(1.228248)-0.99)/dnorm(1.228248)=1.759464 . This result then gets appended to the end of vector xj .

This continues for 10 iterations when the loop ends. Finally, xj is printed to the console:

[1] 0.000000 1.228248 1.759464 2.104157 2.280355 2.324003 2.326341 2.326348
 [9] 2.326348 2.326348 2.326348  

As you can see, the algorithm converges after the 7th iteration, so increasing the number of times the loop runs will cause the program to continually append the vector xj with the same final value, 2.326348 . If you want to observe each iteration individually, you can simply remove the for statement from the sixth line and the curly brackets surrounding it and run the last four lines repeatedly.

Answer 2

This just seems like bad programming. Basically the first step of the for loop takes the result of f(x,0.99) with x=0 and store it as the new value of x. This new value is then stored as a new element of xj with the first element being 0. As the for loop goes through the iterations, a new x gets calculated from f(x,0.99) and is stored as new element of xj.

I say that this is bad programming practice, because when you do something like xj <- c(xj,x) , the vector "xj" runs out of room for a new element "x", so R creates a new vector with length(xj)+1 elements and copies the whole xj into the new vector. R does this every time it goes through xj <- c(xj,x) . While this is fine if the algorithm converges in small number of steps (and is generally the case with Newton's method), but it becomes slow for other algorithms where it takes a large number of steps to converge.

An better, but not perfect alternative to xj <- c(xj,x) would be to first declare xj as a vector of length n, say xj = rep(NA, n) (where n is the approximate number of steps the algorithm converges or larger), then only return the xj elements that are not NAs. This way, even if you pick a large n, it will still be much faster than xj <- c(xj,x) .