Mathematica 9 is now available
Services & Resources / Wolfram Forums
-----
 /
MathGroup Archive
1999
*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 1999

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

Search the Archive

Re: Standard Evaluation with UpValues

  • To: mathgroup at smc.vnet.net
  • Subject: [mg19405] Re: [mg19355] Standard Evaluation with UpValues
  • From: "Andrzej Kozlowski" <andrzej at tuins.ac.jp>
  • Date: Mon, 23 Aug 1999 13:57:17 -0400
  • Sender: owner-wri-mathgroup at wolfram.com

It seems to me that the problem with your example is that g does not hold 
its arguments so they are evaluated before naything else is done. When this
happens naturally the DownValue for f is used. To see this just give g the
HoldAll attribute:

In[1]:=
ClearAll[f, g, t];


In[2]:=
f[x_?NumericQ] := 1 + x;

In[3]:=
f /: g[f[x_]] := x + 4;

In[4]:=
SetAttributes[g, HoldAll]

In[5]:=
g[f[E]]
Out[5]=
4 + E

which agrees with Wagner's book.
--
Andrzej Kozlowski
Toyama International University
JAPAN
http://sigma.tuins.ac.jp
http://eri2.tuins.ac.jp


----------
>From: "Ersek, Ted R" <ErsekTR at navair.navy.mil>
To: mathgroup at smc.vnet.net
>To: mathgroup at smc.vnet.net
>Subject: [mg19405] [mg19355] Standard Evaluation with UpValues
>Date: Sat, Aug 21, 1999, 4:09 AM
>

> Section 7.1.3 of the excellent book "Power Programming With Mathematica The
> Kernel" by David B. Wagner explains the main evaluation loop.  In that
> Section it indicates UpValues for a symbol are applied before DownValues for
> the symbol are applied.
>
> OK then consider the case below where (f) has both an UpValue and a
> DownValue defined by the user.
>
> At Out[4] the UpValue for (f) was used.  In that case the DownValue couldn't
> be used to evaluate f[t].
> Then at Out[5] the DownValue for (f) is used to evaluate  f[E] --> 1+E
> before the kernel checked to see if the UpValue would apply (and it would
> have).  I get the same result using Versions 3 and 4.
>
> When the kernel evaluates g[f[E]] it must figure out that the Head is (g)
> before it evaluates f[E].  After determining that the Head is (g) it checks
> to see if (g) has any Hold* attributes, and continues with evaluation as
> required.  So by the time the kernel evaluates f[E] it has all the
> information it needs to know that the UpValue for (f) can be used.  However,
> the DownValue is used instead.  Wait a minute, aren't UpValues applied
> before DownValues are applied?
>
> Can someone convince me that the main evaluation loop performs as explained
> by David Wagner when evaluating In[5] below?  Also can someone give a
> different example that more clearly shows that UpValues are used first?
> ------------------------------
>
> In[1]:=
> ClearAll[f,g,t];
> f[x_?NumericQ]:=1+x;
> f/:g[f[x_]]:=x+4;
>
>
> In[4]:=
> g[f[t]]
>
> Ou[4]=
> 4+t
>
>
> In[5]:=
> g[f[E]]
>
> Out[5]=
> g[1+E]
>
> --------------------
> Regards,
> Ted Ersek
>
> For Mathematica tips, tricks see
> http://www.dot.net.au/~elisha/ersek/Tricks.html
>
>
> 


  • Prev by Date: RE:Any examples of FEA in Mathematica?
  • Next by Date: Re: Simulation
  • Previous by thread: Re: Standard Evaluation with UpValues
  • Next by thread: Re: Standard Evaluation with UpValues