From luke at stat.uiowa.edu  Wed Apr  4 19:46:56 2007
From: luke at stat.uiowa.edu (Luke Tierney)
Date: Wed, 4 Apr 2007 12:46:56 -0500 (CDT)
Subject: [Rd] Exchange of information between functions aside from
 argument/return-value interface
In-Reply-To: <4613DF85.6030002@uni-bayreuth.de>
References: <4613DF85.6030002@uni-bayreuth.de>
Message-ID: <Pine.LNX.4.64.0704041245320.17651@nokomis.stat.uiowa.edu>

On Wed, 4 Apr 2007, Peter Ruckdeschel wrote:

> Hi R-devels,
>
> I would like to ask for your advice on the preferred way to exchange
> information between functions aside from the regular argument/return-value
> interface.
>
> I am well aware that, S being a functional language, this is to be avoided
> where possible. There are exceptions, though:
>
> Let myF() and myH() be functions provided by me, and notmyG() be a function
> provided by someone else.
>
> The calling hierarchie is myF() calls notmyG() which calls --- possibly
> with other functions being called in between ---  myH().
>
> notmyG() takes as argument a function with return value of type numeric
> --- typically a function for optimizing, integrating or zero-finding ---
> and is a function which I do not want to modify (and subsequently maintain
> the modification).
>
> As myH() is expensive as to evaluation time and, as a side effect, also
> provides important side information, I would like to pass this information
> back to myF(). (Also see example below).
>
> Using information from myF() in myH() by lexical scoping is straight
> forward, whereas to pass information from myH() to myF() directly, the
> solution I found so far is to use assign() with a corresponding
> envir=./pos=.-argument.
>
> (Q1) Is there a better way to do so?
>

Sounds like lexical scoping should work for this also -- use <<- to
assign to the variable in the containing scope.

Best,

luke

> While it is not too difficult to find out the correct value for the
> envir/pos argument when using "pure" R-functions for notmyG(), the
> situation is a little more complicated as soon as notmyG() calls myH()
> through intermediate calls to .Internal() as in case of optim(),
> uniroot().
>
> Is there any way to
>
> (Q2a) find out a corresponding correct value for argument envir/pos in assign
>      ---on run-time---, i.e. how many layers of calls are between
>      myF() and myH()?
>
> --- my first guess was to use sys.frame() but I am not convinced...
>
> (Q2b) to make myH() when called from within a call to .Internal()
>      perform assignments in the environment of myF()
>
> ?
>
> Or should we proceed in a completely different way?
>
> Thank you already for your advice,
>
> Peter
>
> --------------------------------------------------------------------------
> --- Example:
>
> To given clipping height b, myH() calculates an "optimal"  influence curve
> which involves determining certain Lagrange multipliers in a fixed-point type
> algorithm.
> To determine b according to a certain criterium, moreover, myH() evaluates
> a function H0 in b, the zero of which will be the "optimal" b.
>
> So to use notmyG()=uniroot() as zero-finder the return value of myH()
> should be H0(b), while myF() should also get to know about the Lagrange
> multipliers determined in myH().
>
> ______________________________________________
> R-devel at r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
>

-- 
Luke Tierney
Chair, Statistics and Actuarial Science
Ralph E. Wareham Professor of Mathematical Sciences
University of Iowa                  Phone:             319-335-3386
Department of Statistics and        Fax:               319-335-3017
    Actuarial Science
241 Schaeffer Hall                  email:      luke at stat.uiowa.edu
Iowa City, IA 52242                 WWW:  http://www.stat.uiowa.edu



[Rd] Exchange of information between functions aside from argument/return-value interface
Luke Tierney