You can’t use the quad* functions in MATLAB to integrate functions of symbolic variables. You should use the int function in Symbolic Math Toolbox for that.

If you can convert your function to a numeric one, check into the function quad2d: http://www.mathworks.com/help/techdoc/ref/quad2d.html which was added a few releases ago.

–Loren

syms Xin theta;
Y(Xin) = (Xin.*log(2))./log((1241482303990085.*(2./Xin - 1).^3)./(2251799813685248.*(Xin - 2).^2) + 1);
fh=@(Xin)quadl(@(theta) Y(size(theta)),0.7,1/cos(theta));
%inner integral in function of dXin between 0.7 and 1/cos(theta)
I1=quadvec(fh,0,(pi/6));
%outer integral in function of dtheta between 0 and pi/6

I received the following errors:

??? Index exceeds matrix dimensions.

Error in ==> quadl at 78
if ~isfinite(y(13))

Error in ==> @(Xin)quadl(@(theta)Y(size(theta)),0,1/cos(theta))

Error in ==> quadvec>g at 26
y(i) = f(X(i)); % this f refers to the argument of quadvec

Error in ==> quadl at 70
y = feval(f,x,varargin{:}); y = y(:).’;

Error in ==> quadvec at 22
q = quadl(@g, varargin{:}); % like quadl, but supplies g as the argument

Instead, any type (double, triple, quadruple etc) can be achieved if
quadv() is used inside integrands, which provides for:

*retaining the vector capacity across all (X, Y …) integration-variables,
i.e. ONE call to quadv() instead of 7 calls to quad() (each of which involves recursive looping);

*variable precision for each value of the upper-level integration-variable:
N.B. In quadv(), the desired tolerance is respected through a vector norm of the vector-of-integrals between iterations.
Hence (in principle) some components may be a bit more precise than others.

———
BTW, quad() & the like should have been built-in-like (e.g. at least implemented as mex .dll’s) rather than SLOOOW script functions.

This is something that Loren may want to change in the design of the MATLAB language …

1. QUADGK is also subject to undersampling in similar fashion, but it does help that it supports improper integrals directly:

>> quadgk(@(x) x.*exp(-x), 0, inf)
ans =
1.0000

2. QUAD2D supports non-rectangular regions directly:

>> a = 4; b = 3;
>> 4*quad2d(@(x,y)ones(size(x)),0,a,0,@(x)b*sqrt(1-(x./a).^2))
ans =
37.6991

–
Mike

I suspect it’s because the integration intervals widen when the integration limits widen, if the function is fairly flat, but might have some “peaks”, the peaks can be undersampled.

You might to contact technical support for more detail.

–Loren

I found some problems while using the quad function. For example, if I want to evaluate the expectation value of an exponential distributed variable, I approximately use the following:

>> quadl(@(x) x.*exp(-x), 0, 100)

ans =

1.0000

It works fine. However, 100 is just an approximation to infinity. So I wonder if I want a more precise answer, I should increase the upper limit. So I decide to use (0,1000). The answer is quite unexpected:

>> quadl(@(x) x.*exp(-x), 0, 1000)

ans =

1.9164e-036

Why does this happen?

The same thing also happens when I use dblquad function:

>> dblquad(@(x, y) y.*exp(-x).*exp(-y).*(y>a*x), 0, 100, 0, 100)

ans =

0.7500

>> dblquad(@(x, y) y.*exp(-x).*exp(-y).*(y>a*x), 0, 1000, 0, 1000)

ans =

4.5183e-025

I have no idea. You should use a debugger with your code to see if that helps. And if you are still stuck, you might work with technical support to sort out the issue.

–Loren