Integration inconsistency with adaptIntegrate - r

Question

I am estimating the probability of a species dispersing across a gridded landscape, given a dispersal kernel (a function of distance) with a maximum dispersal distance. I'm attempting to calculate area-to-area dispersal probabilities as described in eqn. 8 of this (open access) paper. This involves quadruple integration, evaluating the value of the dispersal function for every possible combination of source and target point in the source and target cells, respectively.
I've implemented this with adaptIntegrate from the cubature package, as follows, for source cell A, target cell B, and a simplified dispersal kernel where dispersal is 1 when the inter-point distance > 1.25 and 0 otherwise. This is shown graphically below, where the red region of cell B is unreachable since no point in cell A is within a distance of 1.25.
library(cubature)
f <- function(xmin, xmax, ymin, ymax) {
adaptIntegrate(function(x) {
r <- sqrt((x[3] - x[1])^2 + (x[4] - x[2])^2)
ifelse(r > 1.25, 0, 1)
},
lowerLimit=c(-0.5, -0.5, xmin, ymin),
upperLimit=c(0.5, 0.5, xmax, ymax),
maxEval=1e5)
}
f(xmin=1.5, xmax=2.5, ymin=-0.5, ymax=0.5)
# $integral
# [1] 0.01949567
#
# $error
# [1] 0.001225998
#
# $functionEvaluations
# [1] 100035
#
# $returnCode
# [1] 0
I get a different integral when considering a target cell, C, that is placed the same distance away, but above rather than to the right of cell A.
f(xmin=-0.5, xmax=0.5, ymin=1.5, ymax=2.5)
# $integral
# [1] 0.01016105
#
# $error
# [1] 0.0241325
#
# $functionEvaluations
# [1] 100035
#
# $returnCode
# [1] 0
Why are these integrals so different (0.01949567 vs 0.01016105)? Have I coded it incorrectly? Changing the tolerance and maximum number of evaluations appears to make no great difference. Alternatively, is there a better approach to coding a solution to this type of problem?
I realise that questions about the general approach are probably better suited to stats.stackexchange.com, but I've posted here since I suspect there may be something that I'm overlooking with the coding itself.
EDIT:
For the A -> B case, nested integrate returns a solution similar to the first adaptIntegrate solution. For the A -> C case, it returns Error in integrate(function(ky) { : the integral is probably divergent.
g <- function(Bx, By, Ax, Ay) {
r <- sqrt((Ax - Bx)^2 + (Ay - By)^2)
ifelse(r > 1.25, 0, 1)
}
integrate(function(Ay) {
sapply(Ay, function(Ay) {
integrate(function(Ax) {
sapply(Ax, function(Ax) {
integrate(function(By) {
sapply(By, function(By) {
integrate(function(Bx) g(Bx, By, Ax, Ay), 1.5, 2.5)$value # Bx
})
}, -0.5, 0.5)$value # By
})
}, -0.5, 0.5)$value # Ax
})
}, -0.5, 0.5)$value # Ay
# [1] 0.019593

Answer 1

The reason for this seems to be the way adaptIntegrate works since, clearly, the only thing that you change is the order of integration. Nonidentical results are likely because of approximate integration alone (see the first response here), but this seems to be more like a bug.
Here are the values of r when computing f(xmin=1.5, xmax=2.5, ymin=-0.5, ymax=0.5)
and f(xmin=-0.5, xmax=0.5, ymin=1.5, ymax=2.5)
so there must be something going on inside the function since the range of values differs dramatically.
One alternative for this is Monte Carlo integration which is good in this case since your points are distributed uniformly.
MCI <- function(Ax, Ay, Bx, By, N, r) {
d <- sapply(list(Ax, Ay, Bx, By), function(l) runif(N, l[1], l[2]))
sum(sqrt((d[, 1] - d[, 3])^2 + (d[, 2] - d[, 4])^2) <= r) / N
}
set.seed(123)
MCI(c(-0.5, 0.5), c(-0.5, 0.5), c(1.5, 2.5), c(-0.5, 0.5), 100000, 1.25)
# [1] 0.0194
MCI(c(-0.5, 0.5), c(-0.5, 0.5), c(-0.5, 0.5), c(1.5, 2.5), 100000, 1.25)
# [1] 0.01929

Answer 2

Generally distance measures are (x1-x2)^2+(y1-y2)^2. Can you explain why you are subtracting the x's from y's when constructing r? Consider the alternate version:
f <- function(xmin, xmax, ymin, ymax) {
adaptIntegrate(function(x) {
r <- sqrt((x[4] - x[3])^2 + (x[2] - x[1])^2)
ifelse(r > 1.25, 0, 1)
},
lowerLimit=c(-0.5, -0.5, xmin, ymin),
upperLimit=c(0.5, 0.5, xmax, ymax),
maxEval=1e5)
}
f(xmin=1.5, xmax=2.5, ymin=-0.5, ymax=0.5)
#-------------
$integral
[1] 0.01016105
$error
[1] 0.0241325
$functionEvaluations
[1] 100035
$returnCode
[1] 0
#---------
f(xmin=-0.5, xmax=0.5, ymin=1.5, ymax=2.5)
#---------
$integral
[1] 0.01016105
$error
[1] 0.0241325
$functionEvaluations
[1] 100035
$returnCode
[1] 0

Answer 3

The maintainer of the R cubature package (Naras) has informed me that the Cubature C library gives the same results as I report in the question above, and that this is unlikely to be a bug; rather, the h-adaptive cubature routine (to which the R package is an interface) is in some cases less accurate than Cubature's p-adaptive routine, which doubles the number of sampling points in appropriate regions.
Naras also provided the following julia code that demonstrates consistent pcubature solutions for the two cases presented in my question (elements of the returned value are the estimated integral followed by the estimated absolute error).
using Cubature
# integrand
f = x -> ifelse(sqrt((x[3] - x[1])^2 + (x[4] - x[2])^2) > 1.25, 0, 1)
# A to B case
pcubature(f, [-0.5, -0.5, 1.5, -0.5], [0.5, 0.5, 2.5, 0.5], abstol=1e-5)
# (0.019593408732917292,3.5592555263398717e-6)
# A to C case
pcubature(f, [-0.5, -0.5, -0.5, 1.5], [0.5, 0.5, 0.5, 2.5], abstol=1e-5)
# (0.019593408732918302,3.559255527241928e-6)