Spliting multiple variable C++ functions for quadrature integration - c++

Question

I want to numerically integrate with boost::math::quadrature::trapezoidal(g, a, b, 1e-6); Here I'm integrating the function g(x). The problem is that I have to perform a double integral. Furthermore, I have 4 variables in the function I want to integrate. 2 of them I pass while integrating (m,n) and the other 2 are the integration variables (r,z). This is the integral I want to compute:
$$
\int_0^b\int_0^af(r,z)\sin{(\frac{n\pi}{a}z)}J_0(\frac{\alpha_{0,m}}{b}r)dzdr
$$
I saw this example Performing 2d numerical integration with Boost Cpp and notices that he uses lambda functions to split the main integrand in 2. so far I have managed this
double integrate(int m, int n)
{
auto f1 = [](double r, double z, int m, int n) { return integrand(r,z,m,n); };
auto f = [&](double r, m) {
auto g = [&](double z, n) {
return f1(r, z);
};
//return gauss_kronrod<double, 61>::integrate(g, 0, a, 5);
return boost::math::quadrature::trapezoidal(g, 0, a, 1e-6);
};
double error;
//double Q = gauss_kronrod<double, 15>::integrate(f, 0, b, 5, 1e-9, &error);
double Q = boost::math::quadrature::trapezoidal(f, 0, b, 1e-6);
//std::cout << Q << ", error estimated at " << error <<std::endl;
return Q;
}
The implementation of the function $f(r,z)$ and the rest of the integral is the following
double initial(double r, double z, int m, int n)
{
return std::sin(M_PI*n*z/a)*std::cyl_bessel_j(0, boost::math::cyl_bessel_j_zero(0,m)*r/b);
}
double integrand(double r,double z,int n,int m)
{
return initial(r,z,m,n)*std::sin(M_PI*n*z/a)*std::cyl_bessel_j(0, boost::math::cyl_bessel_j_zero(0,m)*r/b);
}
Normally the Initial won't need them and n variables but in this case, I need to make some tests.
The problem is that I really don't understand how to split my function like in the example for my problem and perform the integration because boost only accepts 1 variable functions.
Please help

Answer 1

The basic idea is, as usual, to integrate in two steps. For this you first solve the inner integral and make another one-dimensional function out of it, which you then pass again to the integrator.
The lambda is used whenever you want to cut down a multi-parameter function to a single-parameter function. In this case, you put all that is not the integrated variable in the lambda capture.
Here is the pseudo-code:
double integrand(double r,double z, int m,int n, double a, double b)
{
//this is the function you want to integrate
}
double integrate(int m, int n)
{
double a=1.0;
double b=1.0;
auto inner_integral = [m,n,a,b](double z)
{
auto f = [z,m,n,a,b](double r) { return integrand(r,z,m,n,a,b);}
return trapezoidal(f,0,a);
}
return trapezoidal(inner_integral,0,b);
};
You probably don't need to write out the lambda capture, i.e. a reference capture with & will likely work as well (auto inner_integral = [&](double z){...}).