Nsryjdtyk

I am having trouble passing arguments through a recursive call to the integrate function. Here is a simple example that illustrates my conundrum.

Consider a function, foo1, that requires a parameter x and returns some transformation of x. For instance:

foo1 = function(x, alpha = 1.5) {

  return(x^alpha)

}

Now consider a function foo2 that also requires x and returns some different transformation:

foo2 = function(x, y, z) {

  return(x * y * z)

}

Now consider a function bar that returns the finite integral (from x to xMax) of any foo-like function, but accepts a vector of multiple values for x:

bar = function(xVals, xMax, ..., fun) {

  return(

    sapply(

      xVals,

      function(xVal) integrate(f = fun, lower = xVal, upper = xMax, ...)$value)

  )

}

Note that foo1's parameter alpha would be passed as part of the ...:

bar(10:20, 100, alpha = 1.5, fun = foo1)  

and foo2's parameters y and z would also be passed as part of the ...:

bar(10:20, 100, y = 2, z = 4, fun = foo2)

I like this arrangement because other required parameters for integrate can also be passed as part of .... For instance, to change the default value of the subdivisions parameter of the integrate function called by bar, one can simply specify:

bar(10:20, 100, y = 2, z = 4, fun = foo2, subdivisions = 200L)

Now, consider a function that integrates bar from xStart to xEnd, but accepts vectors for multiple values for xStart and xEnd. It might look like this:

integrateBar = function(xStart, xEnd, xMax, ..., fun) {

  aMatrix = cbind(xStart, xEnd)

  result =

    apply(

      aMatrix,

      1,

      function(xRange) integrate(bar, xRange[1], xRange[2], xMax, ..., fun = fun)$value

    )

  return(result)

}

So this is fine and pretty straightforward, until I want to call integrateBar but change the value of the subdivisions argument for the integrate function called within bar. If I use:

integrateBar(10:20, 40, 100, alpha = 1.5, subdivisions = 200L, fun = foo1)

the subdivisions argument is grabbed and used by the integrate function in integrateBar and is not passed through to bar. This is desirable behavior - sometimes. But sometimes I also want to be able to leave subdivisions set at the default for the integrate call in integrateBar but change it for the integrate call in bar. Can anyone tell me an elegant way to do the latter?

I'm willing to modify the formals for bar, but I'm trying not to make it too clunky because I want to call bar directly, too. It would be really nice if there were some R trick so that a subdivisions argument would be ignored by the first integrate function encountered, but available to the second.

The best solution I have is to write a wrapper for integrate that uses a parameter SUBDIVISIONS and call the wrapper from bar. If I don't get a better answer, I will post that solution.

The argument subdivisions is not passed further from integrate, because it is an actual named argument of integrate (only arguments in ...) will be passed to f:

> integrate

# function (f, lower, upper, ..., subdivisions = 100L, rel.tol = .Machine$double.eps^0.25, 

#    abs.tol = rel.tol, stop.on.error = TRUE, keep.xy = FALSE, 

#    aux = NULL)

One possible solution that does not require changing bar would be to write a wrapper for bar inside integrateBar. I have two variants:

Variant 1:
If you want to pass the arguments in ... to both, the outer and the inner call to integrate, this would be it:

integrateBar = function(xStart, xEnd, xMax, ..., fun) {



    argsExtra <- list(...)



    # A wrapper function for bar:

    # Note that the argument ... is necessary, although the function does not use

    # it. This is because, we still pass ... to the call to integrate below. 

    CallBarOnFun <- function(xVals, xMax, ...) {

      do.call(bar, c(list(xVals, xMax), argsExtra, list(fun=fun)))

    }



    aMatrix = cbind(xStart, xEnd)

    result =

      apply(

        aMatrix,

        1,

        function(xRange) {

            integrate(CallBarOnFun, xRange[1], xRange[2], xMax, ...)$value

        } 

      )

    return(result)

}

Variant 2: If you want to pass the arguments in ... only to the inner call:

integrateBar = function(xStart, xEnd, xMax, ..., fun) {

    argsExtra <- list(...)



    CallBarOnFun <- function(xVals, xMax) {

        do.call(bar, c(list(xVals, xMax), argsExtra, list(fun=fun)))

    }



    aMatrix = cbind(xStart, xEnd)

    result =

      apply(

         aMatrix,

         1,

         function(xRange) {

             integrate(CallBarOnFun, xRange[1], xRange[2], xMax)$value

         } 

       )

    return(result)

}