An Error in R: When I try to apply outer function:

Question

Here is my code: Step1: Define a inverse function which I will use later

inverse = function (f, lower = -100, upper = 100) {
  function (y) uniroot((function (x) f(x) - y), lower = lower, upper = upper)[1]
}

Step2: Here is my functions and their inverse:

F1<-function(x,m1,l,s1,s2){l*pnorm((x-m1)/s1)+(1-l)*pnorm((x+m1)/s2)}

F1_inverse = inverse(function(x) F1(x,1,0.1,2,1) , -100, 100)

F2<-function(x,m2,l,s1,s2){l*pnorm((x-m2)/s1)+(1-l)*pnorm((x+m2)/s2)}

F2_inverse = inverse(function(x) F1(x,1,0.1,2,1) , -100, 100)

Step3: Here is my final function which combines the above functions (I am sure the function is correct):

copwnorm<-function(x,y,l,mu1,mu2,sd1,sd2) {
  (l*dnorm(((F1_inverse(pnorm(x))$root-mu1)/sd1))*
    dnorm(((F2_inverse(pnorm(y))$root-mu2)/sd1)))
}

Step4: I want to create a contour plot for the function in Stepenter code here3:

x<-seq(-2,2,0.1)
y<-seq(-2,2,0.1)

z<-outer(x,y,copwnorm)

contour(x,y,z,xlab="x",ylab="y",nlevels=15)

Here is the problem comes in, when I tried to apply function outer(x,y,copwnorm), it gives me an error:invalid function value in 'zeroin'. May I ask how to solve this problem?

Answer 1

I believe it is a very commom misconception to assume that outer(x, y, FUN) calls the function parameter (FUN) once for each required pair x[i] and y[j]. Actually, outer calls FUN only once, after creating all possible pairs, combining every element of x with every element of y, in a manner similar to the function expand.grid.

I'll show that with an example: consider this function, which is a wrapper for the product and print a message every time it's called:

f <- function(x,y)
{
    cat("f called with arguments: x =", capture.output(dput(x)), "y =", capture.output(dput(y)), "\n")

    x*y
}

This function is "naturally" vectorized, so we can call it with vector arguments:

> f(c(1,2), c(3,4))
f called with arguments: x = c(1, 2) y = c(3, 4) 
[1] 3 8

Using outer:

> outer(c(1,2), c(3,4), f)
f called with arguments: x = c(1, 2, 1, 2) y = c(3, 3, 4, 4) 
     [,1] [,2]
[1,]    3    4
[2,]    6    8

Notice the combinations generated.

If we can't guarantee that the function can handle vector arguments, there is a simple trick to ensure the function gets called only once for each pair in the combinations: Vectorize. This creates another function that calls the original function once for each element in the arguments:

> Vectorize(f)(c(1,2),c(3,4))
f called with arguments: x = 1 y = 3 
f called with arguments: x = 2 y = 4 
[1] 3 8

So we can make a "safe" outer with it:

> outer(c(1,2), c(3,4), Vectorize(f))
f called with arguments: x = 1 y = 3 
f called with arguments: x = 2 y = 3 
f called with arguments: x = 1 y = 4 
f called with arguments: x = 2 y = 4 
     [,1] [,2]
[1,]    3    4
[2,]    6    8

In this case, the results are the same because f was written in a vectorized way, i.e., because "*" is vectorized. But if your function is not written with this in mind, using it directly in outer may fail or (worse) may give wrong results.