Services & Resources / Wolfram Forums
-----
 /
MathGroup Archive
2002
*January
*February
*March
*April
*May
*June
*July
*August
*September
*October
*November
*December
*Archive Index
*Ask about this page
*Print this page
*Give us feedback
*Sign up for the Wolfram Insider

MathGroup Archive 2002

[Date Index] [Thread Index] [Author Index]

Search the Archive

RE: RE: Re: Is it possible to access internal variables?

  • To: mathgroup at smc.vnet.net
  • Subject: [mg34781] RE: [mg34749] RE: [mg34709] Re: [mg34705] Is it possible to access internal variables?
  • From: "DrBob" <majort at cox-internet.com>
  • Date: Thu, 6 Jun 2002 01:55:06 -0400 (EDT)
  • Reply-to: <drbob at bigfoot.com>
  • Sender: owner-wri-mathgroup at wolfram.com

>>The expressions e1, e2, up to en are executed in order

No, unfortunately.

(If we can't say what the rules are, we're permanently in trouble.)

pr=.;
{Print[pr],pr=Print,pr[2]};Evaluate[{Print[1],pr[3]}]

1
pr
2
3
{Null,Null}

Evaluate is taken out of sequence so that 1 is printed first.

I can adjust to this if I know in advance which statements will be taken
out of order.  Is Evaluate the only case?

For now, I'll remember that I don't want to enclose in Evaluate anything
that might have side-effects.  Even if I WANT those side-effects to
occur first in a compound expression, it's smarter to put them at the
beginning so that they occur when a naive reader would expect it.

Bobby Treat

-----Original Message-----
From: Wolf, Hartmut [mailto:Hartmut.Wolf at t-systems.com] 
To: mathgroup at smc.vnet.net
Subject: [mg34781] RE: [mg34749] RE: [mg34709] Re: [mg34705] Is it possible to
access internal variables?

Hello Bobby, 
Two things: (1) as Hob Hanlon has pointed out, I missed to assign to v
at definiton of h[x_], which of course explains everything. Aside from
being this my standard blunder mixing up Append with AppendTo in my mind
from my first day on with Mathematica, I did not look close enough, and
finally: there are no mysteries. Sorry for disturbing you. 
(2) What considers CompoundExpression: this is no bug for shure; instead
we simply have to recognize the precise semantics of (e1; e2; ...; en)
The expressions e1, e2, up to en are executed in order, then the result
of en is assigned to CompoundExpression[e1, e2, ..., en] and then this
is evaluated again. Normaly, this has no visible effect since the
execution environment of en when evaluated within the CompoundExpression
is the same as that of the CompoundExpression when it returns; yet this
is not enough. Here, since FindMinimum fails it returns itself
unevaluated (a standard behaviour), this now becomes the value of
CompoundExpression and such FindMinimum will start anew.
This all conforms to the execution sequence as specified for
Mathematica. We certainly should have internalized this precisely and
permanently (as a morning prayer). However, we are human beings, and
build up our own rules in our heads and take many shortcuts. It's there
where we often become irritated. We just have concede that
In[1]:= expr1 
In[2]:= expr2 
is *not* the same as 
In[1]:= expr1; 
 expr2 
As I mentioned I've seen a prior thread to this theme with a prominent
contribution of Allan Hayes, e.g. 
http://library.wolfram.com/mathgroup/archive/1999/Feb/msg00460.html or
see also my reply to Allan at another thread
http://library.wolfram.com/mathgroup/archive/2000/Jul/msg00115.html .
BTW esp. with Block, things are quite the same, and quite common here,
since the execution 
environment within Block almost always differs form that one outside: we
have to anticipate the transformations to the _result_ of Block, as here
to the _result_ of CompoundExpression.
-- 
Hartmut 

> -----Original Message----- 
> From: DrBob [mailto:majort at cox-internet.com] 
To: mathgroup at smc.vnet.net
> Sent: Tuesday, June 04, 2002 5:59 PM 
> Cc: 'David Park'; BobHanlon at aol.com 
> Subject: [mg34781] RE: [mg34749] RE: [mg34709] Re: [mg34705] Is it possible to 
> access internal variables? 
> 
> 
> If compound expressions are not evaluated in order, how can Modules or

> Blocks work?  Aren't they compound expressions?  What makes g and h 
> different? 
> 
> These are serious bugs. 
> 
> I feel like we're walking on quicksand, now. 
> 
> Bobby 
> 
> -----Original Message----- 
> From: Wolf, Hartmut [mailto:Hartmut.Wolf at t-systems.com] 
To: mathgroup at smc.vnet.net
> Sent: Tuesday, June 04, 2002 3:45 AM 
> Subject: [mg34781] [mg34749] RE: [mg34709] Re: [mg34705] Is it possible 
> to access 
> internal variables? 
> 
> 
> Hello Bob, 
> 
> there is something mysterious with your proposal that disturbs me 
> somewhat. 
> See my records: 
> 
> In[1]:= f[x_] := (x - 3)(x - 4) 
>  
> In[2]:= g[x_] := Module[{t = f[x]}, v = Append[v, {x, t}]; t]; 
> In[3]:= v = {}; FindMinimum[g[x], {x, 2, 1, 3}] 
> >From In[3]:= 
> FindMinimum::"regex": "Reached the point \!\({3.5000000000000018`}\) 
> which 
> is \ 
> outside the region \!\({\({1.`, 3.`}\)}\)." 
> >From In[3]:= 
> FindMinimum::"regex": "Reached the point \!\({3.5000000000000018`}\) 
> which 
> is \ 
> outside the region \!\({\({1.`, 3.`}\)}\)." 
> Out[3]= 
> FindMinimum[g[x], {x, 2, 1, 3}] 
> 
> In[4]:= v 
> Out[4]= 
> {{2., 2.}, {2., 2.}, {2.03136, 1.9069}, {2.05074, 1.85035}, {2.18642, 
>     1.4755}, {3., 0.}, {2., 2.}, {2., 2.}, {2.03136, 1.9069}, 
> {2.05074, 
>     1.85035}, {2.18642, 1.4755}, {3., 0.}} 
> 
> In[5]:= g[x] 
> Out[5]= (-4 + x) (-3 + x) 
> 
> In[6]:= ?g 
> Global`g 
> g[x_] := Module[{t = f[x]}, v = Append[v, {x, t}]; t] 
> 
> Apart from the fact that FindMinimum is restarted and that the first 
> value 
> appears twice, this seems to be what you intended. It doesn't 
> help Arny 
> though, as the minimum value -- what he supposed to be that x occuring

> in 
> the error message -- is not included in that list v. 
> 
> But there seems to be something special with g, if I try with h it 
> doesn't 
> work: 
>  
> In[7]:= h[x_] := Module[{t = f[x]}, Append[v, {x, t}]; t]; 
> In[8]:= v = {}; FindMinimum[h[x], {x, 2, 1, 3}] 
> >From In[8]:= 
> FindMinimum::"regex": "Reached the point \!\({3.5000000000000018`}\) 
> which 
> is \ 
> outside the region \!\({\({1.`, 3.`}\)}\)." 
> >From In[8]:= 
> FindMinimum::"regex": "Reached the point \!\({3.5000000000000018`}\) 
> which 
> is \ 
> outside the region \!\({\({1.`, 3.`}\)}\)." 
> Out[8]= 
> FindMinimum[h[x], {x, 2, 1, 3}] 
> 
> In[9]:= v     (* v is empty *) 
> Out[9]= {}       
> 
> In[10]:= h[x] 
> Out[10]= (-4 + x) (-3 + x) 
> 
> In[11]:= ?h 
> Global`h 
> h[x_] := Module[{t = f[x]}, Append[v, {x, t}]; t] 
> 
> 
> Now observe: 
> 
> In[12]:= FindMinimum[Print[x]; f[x], {x, 2, 1, 3}] 
> >From In[12]:= x 
> >From In[12]:= 2. 
> >From In[12]:= 2.03136 
> >From In[12]:= 2.05074 
> >From In[12]:= 2.18642 
> >From In[12]:= 3. 
> >From In[12]:= FindMinimum::"regex": "Reached the point 
> \!\({3.5000000000000018`}\) which is \ 
> outside the region \!\({\({1.`, 3.`}\)}\)." 
> Out[12]= FindMinimum[Print[x]; f[x], {x, 2, 1, 3}] 
> 
> The Argument of FindMinimum is evaluated first with symbolic x (to get

> at 
> the derivative I suppose), later, at the second call, it and 
> such also t 
> = 
> (-4 + x) (-3 + x) get a numeric value, and therefore the values are 
> introduced into v when appending {x,t}, so the start value 
> gets doubled. 
> 
> 
> The restart of the minimization seems to be triggered by the compound 
> expression v = {}; FindMinimum[...] in the main loop (not within Find 
> Minimum) 
>  
> In[19]:= h5[x_] := Module[{t = f[x]}, Print[x]; t]; 
> 
> In[20]:= v = {}; FindMinimum[h5[x], {x, 2, 1, 3}] 
> >From In[20]:= x 
> >From In[20]:= 2. 
> >From In[20]:= 2.03136 
> >From In[20]:= 2.05074 
> >From In[20]:= 2.18642 
> >From In[20]:= 3. 
> >From In[20]:= 
> FindMinimum::"regex": "Reached the point \!\({3.5000000000000018`}\) 
> which 
> is \ 
> outside the region \!\({\({1.`, 3.`}\)}\)." 
> >From In[20]:= x 
> >From In[20]:= 2. 
> >From In[20]:= 2.03136 
> >From In[20]:= 2.05074 
> >From In[20]:= 2.18642 
> >From In[20]:= 3. 
> >From In[20]:= 
> FindMinimum::"regex": "Reached the point \!\({3.5000000000000018`}\) 
> which 
> is \ 
> outside the region \!\({\({1.`, 3.`}\)}\)." 
> Out[20]= FindMinimum[h5[x], {x, 2, 1, 3}] 
> 
> Any expression e.g. (3; FindMinimum[...]) does that too; conversely if

> you 
> initialize v in an extra line, there will be no restart. This may have

> something to do with peculiarities of compound expression, sometimes 
> starting a re-evaluation. (This had been reported by Allan Hayes some 
> years 
> ago.) See: 
> 
> In[65]:= x = 5; 
> 
> In[66]:= x =.; Print[x]; {x, x = 3, x} 
> >From In[66]:= x 
> Out[66]= {3, 3, 3} 
> 
> In[67]:= x =. 
> In[68]:= {x, x = 3, x} 
> Out[68]= {x, 3, 3} 
> 
> Anyways, as shown above, Arny's desire to get at 'internal values' of 
> FindMinimum seems to be hopeless. My advice would be to check for the 
> error 
> message and then possibly increase the search range (by a certain 
> tolerance) 
> and restart (only a finite number of times). 
> 
> -- 
> Hartmut 
> 
> 
> > -----Original Message----- 
> > From: BobHanlon at aol.com [mailto:BobHanlon at aol.com] 
To: mathgroup at smc.vnet.net
> > Sent: Sunday, June 02, 2002 7:15 AM 
> > Subject: [mg34781] [mg34749] [mg34709] Re: [mg34705] Is it possible to access 
> internal 
> > variables? 
> > 
> > 
> > 
> > In a message dated 6/1/02 6:18:58 AM, 
> > someone at somewhere.sometime writes: 
> > 
> > >I am minimizing a function which only has real values 
> > >between 1 and -1, 
> > most 
> > >of the time... occasionally its range is different and 
> > unknown, (but anyway 
> > >not far from 1 and -1).  I could write a routine using Check 
> > to catch errors 
> > >and then expand the range over which FindMinimum is allowed 
> > to search, 
> > >but 
> > >since FindMinimum seems to be getting the appropriate values 
> > anyway - it 
> > >tells me the values in its error message -  I was wondering 
> > if there weren't 
> > >some way to get at those values and use them without 
> > bothering to write 
> > >said routine.  I was thinking of analysing 'MessageList' or 
> > '$MessageList', 
> > >but was thinking there might be some easier way. 
> > > 
> > >Aren't variables within packages accessible via their long 
> > names, e.g. 
> > >`package`private`variablename or something like that?  Does 
> > anyone have 
> > >any suggestions? 
> > > 
> > 
> > f[x_] := (x-3)(x-4); 
> > 
> > g[x_] := Module[{t = f[x]}, v=Append[v, {x,t}]; t]; 
> > 
> > g is the same function as f except that calls to g are recorded in v

> > 
> > v={}; FindMinimum[g[x], {x, 2}] 
> > 
> > {-0.25, {x -> 3.5}} 
> > 
> > FindMinimum called g at the following values of x: 
> > 
> > v[[All,1]] 
> > 
> > {2., 2., 2.0313609375, 2.0507430627940644, 
> >  
> >   2.1864179398525154, 3.136142079261673, 3.500000000000001, 
> >  
> >   3.838316500294484, 3.5, 3.3180710396308366, 
> >  
> >   3.4999904004703097, 3.5, 3.499999994722301} 
> > 
> > 
> > Bob Hanlon 
> > Chantilly, VA  USA 
> > 
> 
> 
> 




  • Prev by Date: Re: TableForm and NumberForm (2)
  • Next by Date: New Units Package On MathSource
  • Previous by thread: Re: RE: Re: Is it possible to access internal variables?
  • Next by thread: RE: RE: Re: Is it possible to access internal variables?