R help - Dec 2011 - efficiently finding the integrals of a sequence of functions

Hi folks,

I am having a question about efficiently finding the integrals of a list of
functions. To be specific,
here is a simple example showing my question.

Suppose we have a function f defined by

f<-function(x,y,z) c(x,y^2,z^3) 

Thus, f is actually corresponding to three uni-dimensional functions
f_1(x)=x, f_2(y)=y^2 and f_3(z)=z^3.
What I am looking for are the integrals of these three functions f_1,f_2,f_3
over some interval, say, (0,1).
More specifically, the integrals \int_0^1 f_1(x) dx, \int_0^1 f_2(y) dy and
\int_0^1 f_3(z) dz.

For this simple example, of course we can do these three integrals one by
one using

integrate (f_1, lower=0, upper=1)

However, in practice, I have a sequence of 5000 uni-dimensional functions
and hope to find all of their 
integrals (over some regions), so using loops to do this one by one is not
efficient. 

A possible idea is to convert the sequence of functions to a list of
objects, and use sapply()
which allow us to find the integrals in a fashion of vectorizing. But I
don't know how to convert
the above example function f to a list. In my research problem, I can only
define the 5000 functions
in a vectorizing way like

f<-function(x1,x2,...,x5000) c(f1(x1),f2(x2),...,f5000(x5000))

So how to convert it to a list will be a crucial step to efficiently get the
integrals.

Thanks for all the suggestions!
Jeff




--
View this message in context:
http://r.789695.n4.nabble.com/efficiently-finding-the-integrals-of-a-sequence-of-functions-tp4179452p4179452.html
Sent from the R help mailing list archive at Nabble.com.

JeffND <Zuofeng.Shang.5 <at> nd.edu> writes:
> 
> Hi folks,
> 
> I am having a question about efficiently finding the integrals of a list of
> functions. 

We had the same discussion last month under the heading "performance of
adaptIntegrate vs. integrate", see

   https://stat.ethz.ch/pipermail/r-help/2011-November/295260.html

It also depends on the accuracy you want to achieve. Adaptive methods will
be slower as the adaptation will be different in each single step for each
function, i.e. no vectorization here.

Non-adaptive Gaussian quadrature appears to be a good candidate. Assume you
have found grid points x_i and weights w_i for your interval [a, b], then if
F is the matrix with F_ij = f_j(x_i) amd the integrals will be computed all
at once with w %*% F .

Example: A function that returns x, x^2, ..., x^5 in columns

  f <- function(x) cbind(x, x^2, x^3, x^4, x^5)

The grid points and weights for the interval [0, 1] are:

  x <- c(0.025446, 0.129234, 0.297077, 0.500000, 0.702923, 0.870766,
0.974554)
  w <- c(0.064742, 0.139853, 0.190915, 0.208980, 0.190915, 0.139853,
0.064742)

and the integrals for these five functions are

    w %*% f(x)      # 0.5 0.3333334 0.25 0.2 0.1666667

Functions to calculate Gaussian points and weights are mentioned in the thread
above.

Hans Werner

> To be specific,
> here is a simple example showing my question.
> 
> Suppose we have a function f defined by
> 
> f<-function(x,y,z) c(x,y^2,z^3) 
> 
> Thus, f is actually corresponding to three uni-dimensional functions
> f_1(x)=x, f_2(y)=y^2 and f_3(z)=z^3.
> What I am looking for are the integrals of these three functions
f_1,f_2,f_3
> over some interval, say, (0,1).
> More specifically, the integrals \int_0^1 f_1(x) dx, \int_0^1 f_2(y) dy and
> \int_0^1 f_3(z) dz.
> 
> For this simple example, of course we can do these three integrals one by
> one using
> 
> integrate (f_1, lower=0, upper=1)
> 
> However, in practice, I have a sequence of 5000 uni-dimensional functions
> and hope to find all of their 
> integrals (over some regions), so using loops to do this one by one is not
> efficient. 
> 
> A possible idea is to convert the sequence of functions to a list of
> objects, and use sapply()
> which allow us to find the integrals in a fashion of vectorizing. But I
> don't know how to convert
> the above example function f to a list. In my research problem, I can only
> define the 5000 functions
> in a vectorizing way like
> 
> f<-function(x1,x2,...,x5000) c(f1(x1),f2(x2),...,f5000(x5000))
> 
> So how to convert it to a list will be a crucial step to efficiently get
the
> integrals.
> 
> Thanks for all the suggestions!
> Jeff
> 
> --
> View this message in context:
http://r.789695.n4.nabble.com/efficiently-finding-the-integrals-of-a-
sequence-of-functions-tp4179452p4179452.html
> Sent from the R help mailing list archive at Nabble.com.
> 
>

Thanks,Hans!

I agree that this is a good way of solving this problem. 

Here is another way. Instead of defining a vector of uni-dimensional
functions and trying to integrating
each component (a uni-dimensional function), we can do something below

my.integrand<-function(x,k)
{
return(f[x,k]) ## use matrix to represent the sequence of uni-dimensional
functions
}

my.integral<-function(k) ## k=1,...,5000 denotes the function labels
{
return(integrate(my.integrand,lower=...,upper=...,k)$value)
}

When calculating the integrals, just perform

sapply(1:5000, my.integral)

This is a way of avoiding loops but the computing time needs to be carefully
examined.

Jeff



--
View this message in context:
http://r.789695.n4.nabble.com/efficiently-finding-the-integrals-of-a-sequence-of-functions-tp4179452p4183323.html
Sent from the R help mailing list archive at Nabble.com.