Functional programming?

Wed, Mar 2, 2016 12:17 PM

Thanks, Roger:

I think Duncan's approach is far more efficient, but I believe the
following replicates your result and may be a bit easier to
understand.

f <- function(u) function(x) u * x^2
g <- function(u) function(x) u * log(x)
set.seed(3)
a <- runif(5)
h <- list()
hit <- list()
h[[1]] <- f(a[1])
hit[[1]] <- f(a[1])
for(i in 2:5) h[[i]] <- eval(bquote(function(x)h[[.(i-1)]](x)*g(a[.(i)])(x)))
x <- 1:99/10
plot(x, h[[1]](x), type = "l")
for(i in 2:5){
  lines(x, h[[i]](x), col = i)
}

This uses recursion to "unwind" h[[i]] each time it's called, ergo
the inefficiency. But in that sense,anyway,  it seems to be more
"functional."

But certainly feel free to ignore.

Cheers,
Bert
Bert Gunter

"The trouble with having an open mind is that people keep coming along
and sticking things into it."
-- Opus (aka Berkeley Breathed in his "Bloom County" comic strip )

On Wed, Mar 2, 2016 at 10:40 AM, Roger Koenker <rkoenker at illinois.edu> wrote:

Thanks, Duncan and Bert,

Duncan?s version does replicate my result, Bert?s does something a bit different,
now I just need some time to digest what you have done, and try to see how
and why.  Many thanks!!!

Roger

url:    www.econ.uiuc.edu/~roger            Roger Koenker
email    rkoenker at uiuc.edu            Department of Economics
vox:     217-333-4558                University of Illinois
fax:       217-244-6678                Urbana, IL 61801

On Mar 2, 2016, at 12:23 PM, Duncan Murdoch <murdoch.duncan at gmail.com> wrote:

On 02/03/2016 11:47 AM, Roger Koenker wrote:

I have a (remarkably ugly!!) code snippet  (below) that, given
two simple functions, f and g,  generates
a list of new functions h_{k+1} =  h_k * g, k= 1, ?, K.  Surely, there are vastly
better ways to do this.  I don?t particularly care about the returned list,
I?d be happy to have the final  h_K version of the function,
but I keep losing my way and running into the dreaded:

Error in h[[1]] : object of type 'closure' is not subsettable
or
Error: evaluation nested too deeply: infinite recursion / options(expressions=)?

Mainly I?d like to get rid of the horrible, horrible paste/parse/eval evils.  Admittedly
the f,g look a bit strange, so you may have to suspend disbelief to imagine that there is
something more sensible lurking beneath this minimal (toy)  example.

    f <- function(u) function(x) u * x^2
    g <- function(u) function(x) u * log(x)
    set.seed(3)
    a <- runif(5)
    h <- list()
    hit <- list()
    h[[1]] <- f(a[1])
    hit[[1]] <- f(a[1])
    for(i in 2:5){
     ht <- paste("function(x) h[[", i-1, "]](x) * g(", a[i], ")(x)")
     h[[i]] <- eval(parse(text = ht))
     hit[[i]] <- function(x) {force(i); return(h[[i]] (x))}
     }
    x <- 1:99/10
    plot(x, h[[1]](x), type = "l")
    for(i in 2:5)
     lines(x, h[[i]](x), col = i)

I don't understand what "hit" is for, but something like this should do it:


hlist <- function(maxk, f,g,a) {
  h <- list()
  h[[1]] <- f(a[1])
  for (j in 2:maxk) {
    h[[j]] <- local({
      k <- j
      function(x) {
        result <- h[[1]](x)
        for (i in 2:k) {
          result <- result*g(a[i])(x)
        }
        result
      }
    })
  }
  h
}

f <- function(u) function(x) u * x^2
g <- function(u) function(x) u * log(x)
set.seed(3)
a <- runif(5)
h <- hlist(5, f, g, a)

Functional programming?

Thread (2 messages)